Zephyr Project API 4.3.2
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
119static inline void
121{
122#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
123 thread->base.usage.longest = 0ULL;
124#endif
125}
126
127typedef void (*k_thread_user_cb_t)(const struct k_thread *thread,
128 void *user_data);
129
145void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data);
146
165#ifdef CONFIG_SMP
166void k_thread_foreach_filter_by_cpu(unsigned int cpu,
167 k_thread_user_cb_t user_cb, void *user_data);
168#else
169static inline
170void k_thread_foreach_filter_by_cpu(unsigned int cpu,
171 k_thread_user_cb_t user_cb, void *user_data)
172{
173 __ASSERT(cpu == 0, "cpu filter out of bounds");
174 ARG_UNUSED(cpu);
175 k_thread_foreach(user_cb, user_data);
176}
177#endif
178
207 k_thread_user_cb_t user_cb, void *user_data);
208
240#ifdef CONFIG_SMP
242 k_thread_user_cb_t user_cb, void *user_data);
243#else
244static inline
245void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
246 k_thread_user_cb_t user_cb, void *user_data)
247{
248 __ASSERT(cpu == 0, "cpu filter out of bounds");
249 ARG_UNUSED(cpu);
250 k_thread_foreach_unlocked(user_cb, user_data);
251}
252#endif
253
255
261
262#endif /* !_ASMLANGUAGE */
263
264
265/*
266 * Thread user options. May be needed by assembly code. Common part uses low
267 * bits, arch-specific use high bits.
268 */
269
273#define K_ESSENTIAL (BIT(0))
274
275#define K_FP_IDX 1
285#define K_FP_REGS (BIT(K_FP_IDX))
286
293#define K_USER (BIT(2))
294
303#define K_INHERIT_PERMS (BIT(3))
304
314#define K_CALLBACK_STATE (BIT(4))
315
325#define K_DSP_IDX 6
326#define K_DSP_REGS (BIT(K_DSP_IDX))
327
336#define K_AGU_IDX 7
337#define K_AGU_REGS (BIT(K_AGU_IDX))
338
348#define K_SSE_REGS (BIT(7))
349
350/* end - thread options */
351
352#if !defined(_ASMLANGUAGE)
377__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);
378
392
444__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
445 k_thread_stack_t *stack,
446 size_t stack_size,
448 void *p1, void *p2, void *p3,
449 int prio, uint32_t options, k_timeout_t delay);
450
473 void *p1, void *p2,
474 void *p3);
475
489#define k_thread_access_grant(thread, ...) \
490 FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)
491
506static inline void k_thread_heap_assign(struct k_thread *thread,
507 struct k_heap *heap)
508{
509 thread->resource_pool = heap;
510}
511
512#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
533__syscall int k_thread_stack_space_get(const struct k_thread *thread,
534 size_t *unused_ptr);
535#endif
536
537#if (K_HEAP_MEM_POOL_SIZE > 0)
550void k_thread_system_pool_assign(struct k_thread *thread);
551#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */
552
572__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);
573
587__syscall int32_t k_sleep(k_timeout_t timeout);
588
600static inline int32_t k_msleep(int32_t ms)
601{
602 return k_sleep(Z_TIMEOUT_MS(ms));
603}
604
622
639__syscall void k_busy_wait(uint32_t usec_to_wait);
640
652bool k_can_yield(void);
653
661__syscall void k_yield(void);
662
672__syscall void k_wakeup(k_tid_t thread);
673
687__attribute_const__
689
701static inline bool k_is_pre_kernel(void)
702{
703 extern bool z_sys_post_kernel; /* in init.c */
704
705 /*
706 * If called from userspace, it must be post kernel.
707 * This guard is necessary because z_sys_post_kernel memory
708 * is not accessible to user threads.
709 */
710 if (k_is_user_context()) {
711 return false;
712 }
713
714 /*
715 * Some compilers might optimize by pre-reading
716 * z_sys_post_kernel. This is absolutely not desirable.
717 * We are trying to avoid reading it if we are in user
718 * context as reading z_sys_post_kernel in user context
719 * will result in access fault. So add a compiler barrier
720 * here to stop that kind of optimizations.
721 */
722 compiler_barrier();
723
724 return !z_sys_post_kernel;
725}
726
733__attribute_const__
734static inline k_tid_t k_current_get(void)
735{
736 __ASSERT(!k_is_pre_kernel(), "k_current_get called pre-kernel");
737
738#ifdef CONFIG_CURRENT_THREAD_USE_TLS
739
740 /* Thread-local cache of current thread ID, set in z_thread_entry() */
741 extern Z_THREAD_LOCAL k_tid_t z_tls_current;
742
743 return z_tls_current;
744#else
746#endif
747}
748
768__syscall void k_thread_abort(k_tid_t thread);
769
770k_ticks_t z_timeout_expires(const struct _timeout *timeout);
771k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
772
773#ifdef CONFIG_SYS_CLOCK_EXISTS
774
782__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
783
784static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
785 const struct k_thread *thread)
786{
787 return z_timeout_expires(&thread->base.timeout);
788}
789
798
799static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
800 const struct k_thread *thread)
801{
802 return z_timeout_remaining(&thread->base.timeout);
803}
804
805#endif /* CONFIG_SYS_CLOCK_EXISTS */
806
810
811struct _static_thread_data {
812 struct k_thread *init_thread;
813 k_thread_stack_t *init_stack;
814 unsigned int init_stack_size;
815 k_thread_entry_t init_entry;
816 void *init_p1;
817 void *init_p2;
818 void *init_p3;
819 int init_prio;
820 uint32_t init_options;
821 const char *init_name;
822#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
823 int32_t init_delay_ms;
824#else
825 k_timeout_t init_delay;
826#endif
827};
828
829#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
830#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
831#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
832#else
833#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS_INIT(ms)
834#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
835#endif
836
837#define Z_THREAD_INITIALIZER(thread, stack, stack_size, \
838 entry, p1, p2, p3, \
839 prio, options, delay, tname) \
840 { \
841 .init_thread = (thread), \
842 .init_stack = (stack), \
843 .init_stack_size = (stack_size), \
844 .init_entry = (k_thread_entry_t)entry, \
845 .init_p1 = (void *)p1, \
846 .init_p2 = (void *)p2, \
847 .init_p3 = (void *)p3, \
848 .init_prio = (prio), \
849 .init_options = (options), \
850 .init_name = STRINGIFY(tname), \
851 Z_THREAD_INIT_DELAY_INITIALIZER(delay) \
852 }
853
854/*
855 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
856 * information on arguments.
857 */
858#define Z_THREAD_COMMON_DEFINE(name, stack_size, \
859 entry, p1, p2, p3, \
860 prio, options, delay) \
861 struct k_thread _k_thread_obj_##name; \
862 STRUCT_SECTION_ITERABLE(_static_thread_data, \
863 _k_thread_data_##name) = \
864 Z_THREAD_INITIALIZER(&_k_thread_obj_##name, \
865 _k_thread_stack_##name, stack_size,\
866 entry, p1, p2, p3, prio, options, \
867 delay, name); \
868 __maybe_unused const k_tid_t name = (k_tid_t)&_k_thread_obj_##name
869
873
905#define K_THREAD_DEFINE(name, stack_size, \
906 entry, p1, p2, p3, \
907 prio, options, delay) \
908 K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
909 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
910 prio, options, delay)
911
942#define K_KERNEL_THREAD_DEFINE(name, stack_size, \
943 entry, p1, p2, p3, \
944 prio, options, delay) \
945 K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
946 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
947 prio, options, delay)
948
958__syscall int k_thread_priority_get(k_tid_t thread);
959
985__syscall void k_thread_priority_set(k_tid_t thread, int prio);
986
987
988#ifdef CONFIG_SCHED_DEADLINE
1020__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);
1021
1062__syscall void k_thread_absolute_deadline_set(k_tid_t thread, int deadline);
1063#endif
1064
1083__syscall void k_reschedule(void);
1084
1085#ifdef CONFIG_SCHED_CPU_MASK
1099
1113
1127
1141
1152int k_thread_cpu_pin(k_tid_t thread, int cpu);
1153#endif
1154
1176__syscall void k_thread_suspend(k_tid_t thread);
1177
1189__syscall void k_thread_resume(k_tid_t thread);
1190
1204static inline void k_thread_start(k_tid_t thread)
1205{
1206 k_wakeup(thread);
1207}
1208
1235void k_sched_time_slice_set(int32_t slice, int prio);
1236
1275void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
1276 k_thread_timeslice_fn_t expired, void *data);
1277
1279
1284
1296bool k_is_in_isr(void);
1297
1314__syscall int k_is_preempt_thread(void);
1315
1319
1324
1350void k_sched_lock(void);
1351
1360
1373__syscall void k_thread_custom_data_set(void *value);
1374
1382__syscall void *k_thread_custom_data_get(void);
1383
1397__syscall int k_thread_name_set(k_tid_t thread, const char *str);
1398
1407const char *k_thread_name_get(k_tid_t thread);
1408
1420__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
1421 size_t size);
1422
1435const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);
1436
1440
1445
1454#define K_NO_WAIT Z_TIMEOUT_NO_WAIT
1455
1468#define K_NSEC(t) Z_TIMEOUT_NS(t)
1469
1482#define K_USEC(t) Z_TIMEOUT_US(t)
1483
1494#define K_CYC(t) Z_TIMEOUT_CYC(t)
1495
1506#define K_TICKS(t) Z_TIMEOUT_TICKS(t)
1507
1518#define K_MSEC(ms) Z_TIMEOUT_MS(ms)
1519
1530#define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
1531
1542#define K_MINUTES(m) K_SECONDS((m) * 60)
1543
1554#define K_HOURS(h) K_MINUTES((h) * 60)
1555
1564#define K_FOREVER Z_FOREVER
1565
1566#ifdef CONFIG_TIMEOUT_64BIT
1567
1579#define K_TIMEOUT_ABS_TICKS(t) \
1580 Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)CLAMP(t, 0, (INT64_MAX - 1))))
1581
1593#define K_TIMEOUT_ABS_SEC(t) K_TIMEOUT_ABS_TICKS(k_sec_to_ticks_ceil64(t))
1594
1606#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))
1607
1620#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))
1621
1634#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))
1635
1648#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
1649
1650#endif
1651
1655
1662struct k_timer {
1666
1667 /*
1668 * _timeout structure must be first here if we want to use
1669 * dynamic timer allocation. timeout.node is used in the double-linked
1670 * list of free timers
1671 */
1672 struct _timeout timeout;
1673
1674 /* wait queue for the (single) thread waiting on this timer */
1675 _wait_q_t wait_q;
1676
1677 /* runs in ISR context */
1678 void (*expiry_fn)(struct k_timer *timer);
1679
1680 /* runs in the context of the thread that calls k_timer_stop() */
1681 void (*stop_fn)(struct k_timer *timer);
1682
1683 /* timer period */
1684 k_timeout_t period;
1685
1686 /* timer status */
1687 uint32_t status;
1688
1689 /* user-specific data, also used to support legacy features */
1690 void *user_data;
1691
1693
1694#ifdef CONFIG_OBJ_CORE_TIMER
1695 struct k_obj_core obj_core;
1696#endif
1700};
1701
1705#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
1706 { \
1707 .timeout = { \
1708 .node = {},\
1709 .fn = z_timer_expiration_handler, \
1710 .dticks = 0, \
1711 }, \
1712 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1713 .expiry_fn = expiry, \
1714 .stop_fn = stop, \
1715 .period = {}, \
1716 .status = 0, \
1717 .user_data = 0, \
1718 }
1719
1723
1729
1740typedef void (*k_timer_expiry_t)(struct k_timer *timer);
1741
1756typedef void (*k_timer_stop_t)(struct k_timer *timer);
1757
1769#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
1770 STRUCT_SECTION_ITERABLE(k_timer, name) = \
1771 Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
1772
1782void k_timer_init(struct k_timer *timer,
1783 k_timer_expiry_t expiry_fn,
1784 k_timer_stop_t stop_fn);
1785
1803__syscall void k_timer_start(struct k_timer *timer,
1804 k_timeout_t duration, k_timeout_t period);
1805
1822__syscall void k_timer_stop(struct k_timer *timer);
1823
1836__syscall uint32_t k_timer_status_get(struct k_timer *timer);
1837
1855__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
1856
1857#ifdef CONFIG_SYS_CLOCK_EXISTS
1858
1869__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
1870
1871static inline k_ticks_t z_impl_k_timer_expires_ticks(
1872 const struct k_timer *timer)
1873{
1874 return z_timeout_expires(&timer->timeout);
1875}
1876
1887__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
1888
1889static inline k_ticks_t z_impl_k_timer_remaining_ticks(
1890 const struct k_timer *timer)
1891{
1892 return z_timeout_remaining(&timer->timeout);
1893}
1894
1905static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
1906{
1908}
1909
1910#endif /* CONFIG_SYS_CLOCK_EXISTS */
1911
1924__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);
1925
1929static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
1930 void *user_data)
1931{
1932 timer->user_data = user_data;
1933}
1934
1942__syscall void *k_timer_user_data_get(const struct k_timer *timer);
1943
1944static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
1945{
1946 return timer->user_data;
1947}
1948
1950
1956
1966__syscall int64_t k_uptime_ticks(void);
1967
1981static inline int64_t k_uptime_get(void)
1982{
1984}
1985
2005static inline uint32_t k_uptime_get_32(void)
2006{
2007 return (uint32_t)k_uptime_get();
2008}
2009
2018static inline uint32_t k_uptime_seconds(void)
2019{
2021}
2022
2034static inline int64_t k_uptime_delta(int64_t *reftime)
2035{
2036 int64_t uptime, delta;
2037
2038 uptime = k_uptime_get();
2039 delta = uptime - *reftime;
2040 *reftime = uptime;
2041
2042 return delta;
2043}
2044
2053static inline uint32_t k_cycle_get_32(void)
2054{
2055 return arch_k_cycle_get_32();
2056}
2057
2068static inline uint64_t k_cycle_get_64(void)
2069{
2070 if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
2071 __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
2072 "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
2073 return 0;
2074 }
2075
2076 return arch_k_cycle_get_64();
2077}
2078
2082
2083struct k_queue {
2086 _wait_q_t wait_q;
2087
2088 Z_DECL_POLL_EVENT
2089
2091};
2092
2096
2097#define Z_QUEUE_INITIALIZER(obj) \
2098 { \
2099 .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
2100 .lock = { }, \
2101 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2102 Z_POLL_EVENT_OBJ_INIT(obj) \
2103 }
2104
2108
2114
2122__syscall void k_queue_init(struct k_queue *queue);
2123
2137__syscall void k_queue_cancel_wait(struct k_queue *queue);
2138
2151void k_queue_append(struct k_queue *queue, void *data);
2152
2169__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);
2170
2183void k_queue_prepend(struct k_queue *queue, void *data);
2184
2201__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);
2202
2216void k_queue_insert(struct k_queue *queue, void *prev, void *data);
2217
2236int k_queue_append_list(struct k_queue *queue, void *head, void *tail);
2237
2253int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);
2254
2272__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);
2273
2290bool k_queue_remove(struct k_queue *queue, void *data);
2291
2306bool k_queue_unique_append(struct k_queue *queue, void *data);
2307
2321__syscall int k_queue_is_empty(struct k_queue *queue);
2322
2323static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
2324{
2325 return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
2326}
2327
2337__syscall void *k_queue_peek_head(struct k_queue *queue);
2338
2348__syscall void *k_queue_peek_tail(struct k_queue *queue);
2349
2359#define K_QUEUE_DEFINE(name) \
2360 STRUCT_SECTION_ITERABLE(k_queue, name) = \
2361 Z_QUEUE_INITIALIZER(name)
2362
2364
2365#ifdef CONFIG_USERSPACE
2375struct k_futex {
2377};
2378
2386struct z_futex_data {
2387 _wait_q_t wait_q;
2388 struct k_spinlock lock;
2389};
2390
2391#define Z_FUTEX_DATA_INITIALIZER(obj) \
2392 { \
2393 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q) \
2394 }
2395
2401
2421__syscall int k_futex_wait(struct k_futex *futex, int expected,
2422 k_timeout_t timeout);
2423
2438__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);
2439
2441#endif
2442
2448
2453
2460
2461struct k_event {
2465 _wait_q_t wait_q;
2466 uint32_t events;
2467 struct k_spinlock lock;
2468
2470
2471#ifdef CONFIG_OBJ_CORE_EVENT
2472 struct k_obj_core obj_core;
2473#endif
2477
2478};
2479
2483
2484#define Z_EVENT_INITIALIZER(obj) \
2485 { \
2486 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2487 .events = 0, \
2488 .lock = {}, \
2489 }
2493
2501__syscall void k_event_init(struct k_event *event);
2502
2520__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);
2521
2539__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);
2540
2557__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
2558 uint32_t events_mask);
2559
2572__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);
2573
2598__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
2599 bool reset, k_timeout_t timeout);
2600
2625__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
2626 bool reset, k_timeout_t timeout);
2627
2647__syscall uint32_t k_event_wait_safe(struct k_event *event, uint32_t events,
2648 bool reset, k_timeout_t timeout);
2649
2669__syscall uint32_t k_event_wait_all_safe(struct k_event *event, uint32_t events,
2670 bool reset, k_timeout_t timeout);
2671
2672
2673
2684static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
2685{
2686 return k_event_wait(event, events_mask, false, K_NO_WAIT);
2687}
2688
2698#define K_EVENT_DEFINE(name) \
2699 STRUCT_SECTION_ITERABLE(k_event, name) = \
2700 Z_EVENT_INITIALIZER(name);
2701
2703
2704struct k_fifo {
2705 struct k_queue _queue;
2706#ifdef CONFIG_OBJ_CORE_FIFO
2707 struct k_obj_core obj_core;
2708#endif
2709};
2710
2714#define Z_FIFO_INITIALIZER(obj) \
2715 { \
2716 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2717 }
2718
2722
2728
2736#define k_fifo_init(fifo) \
2737 ({ \
2738 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
2739 k_queue_init(&(fifo)->_queue); \
2740 K_OBJ_CORE_INIT_UNLINKED(K_OBJ_CORE(fifo), _obj_type_fifo); \
2741 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo); \
2742 })
2743
2755#define k_fifo_cancel_wait(fifo) \
2756 ({ \
2757 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
2758 k_queue_cancel_wait(&(fifo)->_queue); \
2759 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
2760 })
2761
2774#define k_fifo_put(fifo, data) \
2775 ({ \
2776 void *_data = data; \
2777 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, _data); \
2778 k_queue_append(&(fifo)->_queue, _data); \
2779 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, _data); \
2780 })
2781
2798#define k_fifo_alloc_put(fifo, data) \
2799 ({ \
2800 void *_data = data; \
2801 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, _data); \
2802 int fap_ret = k_queue_alloc_append(&(fifo)->_queue, _data); \
2803 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, _data, fap_ret); \
2804 fap_ret; \
2805 })
2806
2821#define k_fifo_put_list(fifo, head, tail) \
2822 ({ \
2823 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
2824 k_queue_append_list(&(fifo)->_queue, head, tail); \
2825 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
2826 })
2827
2841#define k_fifo_put_slist(fifo, list) \
2842 ({ \
2843 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
2844 k_queue_merge_slist(&(fifo)->_queue, list); \
2845 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
2846 })
2847
2865#define k_fifo_get(fifo, timeout) \
2866 ({ \
2867 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
2868 void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
2869 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
2870 fg_ret; \
2871 })
2872
2886#define k_fifo_is_empty(fifo) \
2887 k_queue_is_empty(&(fifo)->_queue)
2888
2902#define k_fifo_peek_head(fifo) \
2903 ({ \
2904 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
2905 void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
2906 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
2907 fph_ret; \
2908 })
2909
2921#define k_fifo_peek_tail(fifo) \
2922 ({ \
2923 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
2924 void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
2925 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
2926 fpt_ret; \
2927 })
2928
2938#define K_FIFO_DEFINE(name) \
2939 STRUCT_SECTION_ITERABLE(k_fifo, name) = \
2940 Z_FIFO_INITIALIZER(name)
2941
2943
2944struct k_lifo {
2945 struct k_queue _queue;
2946#ifdef CONFIG_OBJ_CORE_LIFO
2947 struct k_obj_core obj_core;
2948#endif
2949};
2950
2954
2955#define Z_LIFO_INITIALIZER(obj) \
2956 { \
2957 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
2958 }
2959
2963
2969
2977#define k_lifo_init(lifo) \
2978 ({ \
2979 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
2980 k_queue_init(&(lifo)->_queue); \
2981 K_OBJ_CORE_INIT_UNLINKED(K_OBJ_CORE(lifo), _obj_type_lifo); \
2982 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo); \
2983 })
2984
2997#define k_lifo_put(lifo, data) \
2998 ({ \
2999 void *_data = data; \
3000 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, _data); \
3001 k_queue_prepend(&(lifo)->_queue, _data); \
3002 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, _data); \
3003 })
3004
3021#define k_lifo_alloc_put(lifo, data) \
3022 ({ \
3023 void *_data = data; \
3024 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, _data); \
3025 int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, _data); \
3026 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, _data, lap_ret); \
3027 lap_ret; \
3028 })
3029
3047#define k_lifo_get(lifo, timeout) \
3048 ({ \
3049 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
3050 void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
3051 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
3052 lg_ret; \
3053 })
3054
3064#define K_LIFO_DEFINE(name) \
3065 STRUCT_SECTION_ITERABLE(k_lifo, name) = \
3066 Z_LIFO_INITIALIZER(name)
3067
3069
3073#define K_STACK_FLAG_ALLOC ((uint8_t)1) /* Buffer was allocated */
3074
3075typedef uintptr_t stack_data_t;
3076
3077struct k_stack {
3078 _wait_q_t wait_q;
3079 struct k_spinlock lock;
3080 stack_data_t *base, *next, *top;
3081
3082 uint8_t flags;
3083
3085
3086#ifdef CONFIG_OBJ_CORE_STACK
3087 struct k_obj_core obj_core;
3088#endif
3089};
3090
3091#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
3092 { \
3093 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3094 .base = (stack_buffer), \
3095 .next = (stack_buffer), \
3096 .top = (stack_buffer) + (stack_num_entries), \
3097 }
3098
3102
3108
3118void k_stack_init(struct k_stack *stack,
3119 stack_data_t *buffer, uint32_t num_entries);
3120
3121
3135
3136__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
3137 uint32_t num_entries);
3138
3150int k_stack_cleanup(struct k_stack *stack);
3151
3165__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);
3166
3187__syscall int k_stack_pop(struct k_stack *stack, stack_data_t *data,
3188 k_timeout_t timeout);
3189
3200#define K_STACK_DEFINE(name, stack_num_entries) \
3201 stack_data_t __noinit \
3202 _k_stack_buf_##name[stack_num_entries]; \
3203 STRUCT_SECTION_ITERABLE(k_stack, name) = \
3204 Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
3205 stack_num_entries)
3206
3208
3212
3213struct k_work;
3214struct k_work_q;
3215struct k_work_queue_config;
3216extern struct k_work_q k_sys_work_q;
3217
3221
3227
3232struct k_mutex {
3234 _wait_q_t wait_q;
3237
3240
3243
3245
3246#ifdef CONFIG_OBJ_CORE_MUTEX
3247 struct k_obj_core obj_core;
3248#endif
3249};
3250
3254#define Z_MUTEX_INITIALIZER(obj) \
3255 { \
3256 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3257 .owner = NULL, \
3258 .lock_count = 0, \
3259 .owner_orig_prio = K_LOWEST_APPLICATION_THREAD_PRIO, \
3260 }
3261
3265
3275#define K_MUTEX_DEFINE(name) \
3276 STRUCT_SECTION_ITERABLE(k_mutex, name) = \
3277 Z_MUTEX_INITIALIZER(name)
3278
3291__syscall int k_mutex_init(struct k_mutex *mutex);
3292
3293
3315__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);
3316
3337__syscall int k_mutex_unlock(struct k_mutex *mutex);
3338
3342
3343
3345 _wait_q_t wait_q;
3346
3347#ifdef CONFIG_OBJ_CORE_CONDVAR
3348 struct k_obj_core obj_core;
3349#endif
3350};
3351
3352#define Z_CONDVAR_INITIALIZER(obj) \
3353 { \
3354 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
3355 }
3356
3362
3369__syscall int k_condvar_init(struct k_condvar *condvar);
3370
3377__syscall int k_condvar_signal(struct k_condvar *condvar);
3378
3386__syscall int k_condvar_broadcast(struct k_condvar *condvar);
3387
3405__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
3406 k_timeout_t timeout);
3407
3418#define K_CONDVAR_DEFINE(name) \
3419 STRUCT_SECTION_ITERABLE(k_condvar, name) = \
3420 Z_CONDVAR_INITIALIZER(name)
3421
3424
3430
3437struct k_sem {
3441 _wait_q_t wait_q;
3442 unsigned int count;
3443 unsigned int limit;
3444
3445 Z_DECL_POLL_EVENT
3446
3448
3449#ifdef CONFIG_OBJ_CORE_SEM
3450 struct k_obj_core obj_core;
3451#endif
3453};
3454
3458
3459#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
3460 { \
3461 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3462 .count = (initial_count), \
3463 .limit = (count_limit), \
3464 Z_POLL_EVENT_OBJ_INIT(obj) \
3465 }
3466
3470
3479#define K_SEM_MAX_LIMIT UINT_MAX
3480
3496__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
3497 unsigned int limit);
3498
3517__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);
3518
3529__syscall void k_sem_give(struct k_sem *sem);
3530
3540__syscall void k_sem_reset(struct k_sem *sem);
3541
3551__syscall unsigned int k_sem_count_get(struct k_sem *sem);
3552
3556static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
3557{
3558 return sem->count;
3559}
3560
3572#define K_SEM_DEFINE(name, initial_count, count_limit) \
3573 STRUCT_SECTION_ITERABLE(k_sem, name) = \
3574 Z_SEM_INITIALIZER(name, initial_count, count_limit); \
3575 BUILD_ASSERT(((count_limit) != 0) && \
3576 (((initial_count) < (count_limit)) || ((initial_count) == (count_limit))) && \
3577 ((count_limit) <= K_SEM_MAX_LIMIT));
3578
3580
3581#if defined(CONFIG_SCHED_IPI_SUPPORTED) || defined(__DOXYGEN__)
3582struct k_ipi_work;
3583
3584
3585typedef void (*k_ipi_func_t)(struct k_ipi_work *work);
3586
3597 sys_dnode_t node[CONFIG_MP_MAX_NUM_CPUS]; /* Node in IPI work queue */
3598 k_ipi_func_t func; /* Function to execute on target CPU */
3599 struct k_event event; /* Event to signal when processed */
3600 uint32_t bitmask; /* Bitmask of targeted CPUs */
3602};
3603
3604
3612static inline void k_ipi_work_init(struct k_ipi_work *work)
3613{
3614 k_event_init(&work->event);
3615 for (unsigned int i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
3616 sys_dnode_init(&work->node[i]);
3617 }
3618 work->bitmask = 0;
3619}
3620
3639int k_ipi_work_add(struct k_ipi_work *work, uint32_t cpu_bitmask,
3640 k_ipi_func_t func);
3641
3664int k_ipi_work_wait(struct k_ipi_work *work, k_timeout_t timeout);
3665
3675
3676#endif /* CONFIG_SCHED_IPI_SUPPORTED */
3677
3681
3682struct k_work_delayable;
3683struct k_work_sync;
3684
3688
3694
3701typedef void (*k_work_handler_t)(struct k_work *work);
3702
3716void k_work_init(struct k_work *work,
3718
3733int k_work_busy_get(const struct k_work *work);
3734
3748static inline bool k_work_is_pending(const struct k_work *work);
3749
3771 struct k_work *work);
3772
3781int k_work_submit(struct k_work *work);
3782
3807bool k_work_flush(struct k_work *work,
3808 struct k_work_sync *sync);
3809
3829int k_work_cancel(struct k_work *work);
3830
3861bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);
3862
3873
3894 k_thread_stack_t *stack, size_t stack_size,
3895 int prio, const struct k_work_queue_config *cfg);
3896
3907void k_work_queue_run(struct k_work_q *queue, const struct k_work_queue_config *cfg);
3908
3918static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);
3919
3943int k_work_queue_drain(struct k_work_q *queue, bool plug);
3944
3959
3976
3992
4004static inline struct k_work_delayable *
4006
4021
4036static inline bool k_work_delayable_is_pending(
4037 const struct k_work_delayable *dwork);
4038
4053 const struct k_work_delayable *dwork);
4054
4069 const struct k_work_delayable *dwork);
4070
4099 struct k_work_delayable *dwork,
4100 k_timeout_t delay);
4101
4116 k_timeout_t delay);
4117
4154 struct k_work_delayable *dwork,
4155 k_timeout_t delay);
4156
4170 k_timeout_t delay);
4171
4197 struct k_work_sync *sync);
4198
4220
4250 struct k_work_sync *sync);
4251
4252enum {
4256
4257 /* The atomic API is used for all work and queue flags fields to
4258 * enforce sequential consistency in SMP environments.
4259 */
4260
4261 /* Bits that represent the work item states. At least nine of the
4262 * combinations are distinct valid stable states.
4263 */
4264 K_WORK_RUNNING_BIT = 0,
4265 K_WORK_CANCELING_BIT = 1,
4266 K_WORK_QUEUED_BIT = 2,
4267 K_WORK_DELAYED_BIT = 3,
4268 K_WORK_FLUSHING_BIT = 4,
4269
4270 K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
4271 | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
4272
4273 /* Static work flags */
4274 K_WORK_DELAYABLE_BIT = 8,
4275 K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
4276
4277 /* Dynamic work queue flags */
4278 K_WORK_QUEUE_STARTED_BIT = 0,
4279 K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
4280 K_WORK_QUEUE_BUSY_BIT = 1,
4281 K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
4282 K_WORK_QUEUE_DRAIN_BIT = 2,
4283 K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
4284 K_WORK_QUEUE_PLUGGED_BIT = 3,
4285 K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
4286 K_WORK_QUEUE_STOP_BIT = 4,
4287 K_WORK_QUEUE_STOP = BIT(K_WORK_QUEUE_STOP_BIT),
4288
4289 /* Static work queue flags */
4290 K_WORK_QUEUE_NO_YIELD_BIT = 8,
4291 K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
4292
4296 /* Transient work flags */
4297
4303 K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),
4304
4309 K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),
4310
4316 K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),
4317
4323 K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),
4324
4329 K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
4330};
4331
4333struct k_work {
4334 /* All fields are protected by the work module spinlock. No fields
4335 * are to be accessed except through kernel API.
4336 */
4337
4338 /* Node to link into k_work_q pending list. */
4340
4341 /* The function to be invoked by the work queue thread. */
4343
4344 /* The queue on which the work item was last submitted. */
4346
4347 /* State of the work item.
4348 *
4349 * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
4350 *
4351 * It can be RUNNING and CANCELING simultaneously.
4352 */
4354};
4355
4356#define Z_WORK_INITIALIZER(work_handler) { \
4357 .handler = (work_handler), \
4358}
4359
4362 /* The work item. */
4363 struct k_work work;
4364
4365 /* Timeout used to submit work after a delay. */
4366 struct _timeout timeout;
4367
4368 /* The queue to which the work should be submitted. */
4370};
4371
4372#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
4373 .work = { \
4374 .handler = (work_handler), \
4375 .flags = K_WORK_DELAYABLE, \
4376 }, \
4377}
4378
4395#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
4396 struct k_work_delayable work \
4397 = Z_WORK_DELAYABLE_INITIALIZER(work_handler)
4398
4402
4403/* Record used to wait for work to flush.
4404 *
4405 * The work item is inserted into the queue that will process (or is
4406 * processing) the item, and will be processed as soon as the item
4407 * completes. When the flusher is processed the semaphore will be
4408 * signaled, releasing the thread waiting for the flush.
4409 */
4410struct z_work_flusher {
4411 struct k_work work;
4412 struct k_sem sem;
4413};
4414
4415/* Record used to wait for work to complete a cancellation.
4416 *
4417 * The work item is inserted into a global queue of pending cancels.
4418 * When a cancelling work item goes idle any matching waiters are
4419 * removed from pending_cancels and are woken.
4420 */
4421struct z_work_canceller {
4422 sys_snode_t node;
4423 struct k_work *work;
4424 struct k_sem sem;
4425};
4426
4430
4445 union {
4446 struct z_work_flusher flusher;
4447 struct z_work_canceller canceller;
4448 };
4449};
4450
4462 const char *name;
4463
4477
4482
4492};
4493
4495struct k_work_q {
4496 /* The thread that animates the work. */
4498
4499 /* The thread ID that animates the work. This may be an external thread
4500 * if k_work_queue_run() is used.
4501 */
4503
4504 /* All the following fields must be accessed only while the
4505 * work module spinlock is held.
4506 */
4507
4508 /* List of k_work items to be worked. */
4510
4511 /* Wait queue for idle work thread. */
4512 _wait_q_t notifyq;
4513
4514 /* Wait queue for threads waiting for the queue to drain. */
4515 _wait_q_t drainq;
4516
4517 /* Flags describing queue state. */
4519
4520#if defined(CONFIG_WORKQUEUE_WORK_TIMEOUT)
4521 struct _timeout work_timeout_record;
4522 struct k_work *work;
4523 k_timeout_t work_timeout;
4524#endif /* defined(CONFIG_WORKQUEUE_WORK_TIMEOUT) */
4525};
4526
4527/* Provide the implementation for inline functions declared above */
4528
4529static inline bool k_work_is_pending(const struct k_work *work)
4530{
4531 return k_work_busy_get(work) != 0;
4532}
4533
4534static inline struct k_work_delayable *
4539
4541 const struct k_work_delayable *dwork)
4542{
4543 return k_work_delayable_busy_get(dwork) != 0;
4544}
4545
4547 const struct k_work_delayable *dwork)
4548{
4549 return z_timeout_expires(&dwork->timeout);
4550}
4551
4553 const struct k_work_delayable *dwork)
4554{
4555 return z_timeout_remaining(&dwork->timeout);
4556}
4557
4559{
4560 return queue->thread_id;
4561}
4562
4564
4565struct k_work_user;
4566
4571
4581typedef void (*k_work_user_handler_t)(struct k_work_user *work);
4582
4586
4587struct k_work_user_q {
4588 struct k_queue queue;
4589 struct k_thread thread;
4590};
4591
4592enum {
4593 K_WORK_USER_STATE_PENDING, /* Work item pending state */
4594};
4595
4596struct k_work_user {
4597 void *_reserved; /* Used by k_queue implementation. */
4598 k_work_user_handler_t handler;
4600};
4601
4605
4606#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
4607#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
4608#else
4609#define Z_WORK_USER_INITIALIZER(work_handler) \
4610 { \
4611 ._reserved = NULL, \
4612 .handler = (work_handler), \
4613 .flags = 0 \
4614 }
4615#endif
4616
4628#define K_WORK_USER_DEFINE(work, work_handler) \
4629 struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)
4630
4640static inline void k_work_user_init(struct k_work_user *work,
4641 k_work_user_handler_t handler)
4642{
4643 *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
4644}
4645
4662static inline bool k_work_user_is_pending(struct k_work_user *work)
4663{
4664 return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
4665}
4666
4685static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
4686 struct k_work_user *work)
4687{
4688 int ret = -EBUSY;
4689
4690 if (!atomic_test_and_set_bit(&work->flags,
4691 K_WORK_USER_STATE_PENDING)) {
4692 ret = k_queue_alloc_append(&work_q->queue, work);
4693
4694 /* Couldn't insert into the queue. Clear the pending bit
4695 * so the work item can be submitted again
4696 */
4697 if (ret != 0) {
4698 atomic_clear_bit(&work->flags,
4699 K_WORK_USER_STATE_PENDING);
4700 }
4701 }
4702
4703 return ret;
4704}
4705
4725void k_work_user_queue_start(struct k_work_user_q *work_q,
4726 k_thread_stack_t *stack,
4727 size_t stack_size, int prio,
4728 const char *name);
4729
4740static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
4741{
4742 return &work_q->thread;
4743}
4744
4746
4750
4751struct k_work_poll {
4752 struct k_work work;
4753 struct k_work_q *workq;
4754 struct z_poller poller;
4755 struct k_poll_event *events;
4756 int num_events;
4757 k_work_handler_t real_handler;
4758 struct _timeout timeout;
4759 int poll_result;
4760};
4761
4765
4770
4782#define K_WORK_DEFINE(work, work_handler) \
4783 struct k_work work = Z_WORK_INITIALIZER(work_handler)
4784
4794void k_work_poll_init(struct k_work_poll *work,
4795 k_work_handler_t handler);
4796
4832 struct k_work_poll *work,
4833 struct k_poll_event *events,
4834 int num_events,
4835 k_timeout_t timeout);
4836
4868int k_work_poll_submit(struct k_work_poll *work,
4869 struct k_poll_event *events,
4870 int num_events,
4871 k_timeout_t timeout);
4872
4887int k_work_poll_cancel(struct k_work_poll *work);
4888
4890
4896
4900struct k_msgq {
4902 _wait_q_t wait_q;
4906 size_t msg_size;
4919
4920 Z_DECL_POLL_EVENT
4921
4924
4926
4927#ifdef CONFIG_OBJ_CORE_MSGQ
4928 struct k_obj_core obj_core;
4929#endif
4930};
4931
4934
4935
4936#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
4937 { \
4938 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
4939 .lock = {}, \
4940 .msg_size = q_msg_size, \
4941 .max_msgs = q_max_msgs, \
4942 .buffer_start = q_buffer, \
4943 .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
4944 .read_ptr = q_buffer, \
4945 .write_ptr = q_buffer, \
4946 .used_msgs = 0, \
4947 Z_POLL_EVENT_OBJ_INIT(obj) \
4948 .flags = 0, \
4949 }
4950
4954
4955
4956#define K_MSGQ_FLAG_ALLOC BIT(0)
4957
4969
4970
4989#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align) \
4990 static char __noinit __aligned(q_align) \
4991 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
4992 STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
4993 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
4994 (q_msg_size), (q_max_msgs))
4995
5010void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
5011 uint32_t max_msgs);
5012
5032__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
5033 uint32_t max_msgs);
5034
5045int k_msgq_cleanup(struct k_msgq *msgq);
5046
5067__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);
5068
5093__syscall int k_msgq_put_front(struct k_msgq *msgq, const void *data);
5094
5115__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);
5116
5131__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);
5132
5149__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);
5150
5160__syscall void k_msgq_purge(struct k_msgq *msgq);
5161
5172__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);
5173
5182__syscall void k_msgq_get_attrs(struct k_msgq *msgq,
5183 struct k_msgq_attrs *attrs);
5184
5185
5186static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
5187{
5188 return msgq->max_msgs - msgq->used_msgs;
5189}
5190
5200__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
5201
5202static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
5203{
5204 return msgq->used_msgs;
5205}
5206
5208
5214
5221 size_t size;
5225 void *tx_data;
5231 k_tid_t _syncing_thread;
5232#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
5234 struct k_sem *_async_sem;
5235#endif
5236};
5237
5241struct k_mbox {
5243 _wait_q_t tx_msg_queue;
5245 _wait_q_t rx_msg_queue;
5247
5249
5250#ifdef CONFIG_OBJ_CORE_MAILBOX
5251 struct k_obj_core obj_core;
5252#endif
5253};
5254
5257
5258#define Z_MBOX_INITIALIZER(obj) \
5259 { \
5260 .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
5261 .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
5262 }
5263
5267
5277#define K_MBOX_DEFINE(name) \
5278 STRUCT_SECTION_ITERABLE(k_mbox, name) = \
5279 Z_MBOX_INITIALIZER(name) \
5280
5281
5288void k_mbox_init(struct k_mbox *mbox);
5289
5309int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
5310 k_timeout_t timeout);
5311
5325void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
5326 struct k_sem *sem);
5327
5345int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
5346 void *buffer, k_timeout_t timeout);
5347
5361void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);
5362
5364
5370
5380__syscall void k_pipe_init(struct k_pipe *pipe, uint8_t *buffer, size_t buffer_size);
5381
5386
5387struct k_pipe {
5388 size_t waiting;
5391 _wait_q_t data;
5392 _wait_q_t space;
5394
5395 Z_DECL_POLL_EVENT
5396#ifdef CONFIG_OBJ_CORE_PIPE
5397 struct k_obj_core obj_core;
5398#endif
5400};
5401
5405#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size) \
5406{ \
5407 .waiting = 0, \
5408 .buf = RING_BUF_INIT(pipe_buffer, pipe_buffer_size), \
5409 .data = Z_WAIT_Q_INIT(&obj.data), \
5410 .space = Z_WAIT_Q_INIT(&obj.space), \
5411 .flags = PIPE_FLAG_OPEN, \
5412 Z_POLL_EVENT_OBJ_INIT(obj) \
5413}
5417
5431#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align) \
5432 static unsigned char __noinit __aligned(pipe_align) \
5433 _k_pipe_buf_##name[pipe_buffer_size]; \
5434 STRUCT_SECTION_ITERABLE(k_pipe, name) = \
5435 Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
5436
5437
5454__syscall int k_pipe_write(struct k_pipe *pipe, const uint8_t *data, size_t len,
5455 k_timeout_t timeout);
5456
5472__syscall int k_pipe_read(struct k_pipe *pipe, uint8_t *data, size_t len,
5473 k_timeout_t timeout);
5474
5484__syscall void k_pipe_reset(struct k_pipe *pipe);
5485
5494__syscall void k_pipe_close(struct k_pipe *pipe);
5496
5500struct k_mem_slab_info {
5501 uint32_t num_blocks;
5502 size_t block_size;
5503 uint32_t num_used;
5504#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5505 uint32_t max_used;
5506#endif
5507};
5508
5509struct k_mem_slab {
5510 _wait_q_t wait_q;
5511 struct k_spinlock lock;
5512 char *buffer;
5513 char *free_list;
5514 struct k_mem_slab_info info;
5515
5517
5518#ifdef CONFIG_OBJ_CORE_MEM_SLAB
5519 struct k_obj_core obj_core;
5520#endif
5521};
5522
5523#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
5524 _slab_num_blocks) \
5525 { \
5526 .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q), \
5527 .lock = {}, \
5528 .buffer = _slab_buffer, \
5529 .free_list = NULL, \
5530 .info = {_slab_num_blocks, _slab_block_size, 0} \
5531 }
5532
5533
5537
5543
5569#define K_MEM_SLAB_DEFINE_IN_SECT(name, in_section, slab_block_size, slab_num_blocks, slab_align) \
5570 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
5571 "slab_block_size must be a multiple of slab_align"); \
5572 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
5573 "slab_align must be a power of 2"); \
5574 char in_section __aligned(WB_UP( \
5575 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5576 STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
5577 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
5578
5602#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align) \
5603 K_MEM_SLAB_DEFINE_IN_SECT(name, __noinit_named(k_mem_slab_buf_##name), slab_block_size, \
5604 slab_num_blocks, slab_align)
5605
5622#define K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, in_section, slab_block_size, slab_num_blocks, \
5623 slab_align) \
5624 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
5625 "slab_block_size must be a multiple of slab_align"); \
5626 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
5627 "slab_align must be a power of 2"); \
5628 static char in_section __aligned(WB_UP( \
5629 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
5630 static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
5631 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
5632
5647#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align) \
5648 K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, __noinit_named(k_mem_slab_buf_##name), \
5649 slab_block_size, slab_num_blocks, slab_align)
5650
5672int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
5673 size_t block_size, uint32_t num_blocks);
5674
5697int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
5698 k_timeout_t timeout);
5699
5711void k_mem_slab_free(struct k_mem_slab *slab, void *mem);
5712
5725static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
5726{
5727 return slab->info.num_used;
5728}
5729
5742static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
5743{
5744#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
5745 return slab->info.max_used;
5746#else
5747 ARG_UNUSED(slab);
5748 return 0;
5749#endif
5750}
5751
5764static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
5765{
5766 return slab->info.num_blocks - slab->info.num_used;
5767}
5768
5782
5783int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);
5784
5798int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);
5799
5801
5806
5807/* kernel synchronized heap struct */
5808
5809struct k_heap {
5811 _wait_q_t wait_q;
5813};
5814
5828void k_heap_init(struct k_heap *h, void *mem,
5829 size_t bytes) __attribute_nonnull(1);
5830
5851void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
5852 k_timeout_t timeout) __attribute_nonnull(1);
5853
5875void *k_heap_alloc(struct k_heap *h, size_t bytes,
5876 k_timeout_t timeout) __attribute_nonnull(1);
5877
5900void *k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
5901 __attribute_nonnull(1);
5902
5926void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
5927 __attribute_nonnull(1);
5928
5939void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
5940
5941/* Minimum heap sizes needed to return a successful 1-byte allocation.
5942 * Assumes a chunk aligned (8 byte) memory buffer.
5943 */
5944#ifdef CONFIG_SYS_HEAP_RUNTIME_STATS
5945#define Z_HEAP_MIN_SIZE ((sizeof(void *) > 4) ? 80 : 52)
5946#else
5947#define Z_HEAP_MIN_SIZE ((sizeof(void *) > 4) ? 56 : 44)
5948#endif /* CONFIG_SYS_HEAP_RUNTIME_STATS */
5949
5966#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section) \
5967 char in_section \
5968 __aligned(8) /* CHUNK_UNIT */ \
5969 kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)]; \
5970 STRUCT_SECTION_ITERABLE(k_heap, name) = { \
5971 .heap = { \
5972 .init_mem = kheap_##name, \
5973 .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
5974 }, \
5975 }
5976
5991#define K_HEAP_DEFINE(name, bytes) \
5992 Z_HEAP_DEFINE_IN_SECT(name, bytes, \
5993 __noinit_named(kheap_buf_##name))
5994
6009#define K_HEAP_DEFINE_NOCACHE(name, bytes) \
6010 Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)
6011
6021int k_heap_array_get(struct k_heap **heap);
6022
6026
6033
6052void *k_aligned_alloc(size_t align, size_t size);
6053
6065void *k_malloc(size_t size);
6066
6077void k_free(void *ptr);
6078
6090void *k_calloc(size_t nmemb, size_t size);
6091
6109void *k_realloc(void *ptr, size_t size);
6110
6112
6113/* polling API - PRIVATE */
6114
6115#ifdef CONFIG_POLL
6116#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
6117#else
6118#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
6119#endif
6120
6121/* private - types bit positions */
6122enum _poll_types_bits {
6123 /* can be used to ignore an event */
6124 _POLL_TYPE_IGNORE,
6125
6126 /* to be signaled by k_poll_signal_raise() */
6127 _POLL_TYPE_SIGNAL,
6128
6129 /* semaphore availability */
6130 _POLL_TYPE_SEM_AVAILABLE,
6131
6132 /* queue/FIFO/LIFO data availability */
6133 _POLL_TYPE_DATA_AVAILABLE,
6134
6135 /* msgq data availability */
6136 _POLL_TYPE_MSGQ_DATA_AVAILABLE,
6137
6138 /* pipe data availability */
6139 _POLL_TYPE_PIPE_DATA_AVAILABLE,
6140
6141 _POLL_NUM_TYPES
6142};
6143
6144#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
6145
6146/* private - states bit positions */
6147enum _poll_states_bits {
6148 /* default state when creating event */
6149 _POLL_STATE_NOT_READY,
6150
6151 /* signaled by k_poll_signal_raise() */
6152 _POLL_STATE_SIGNALED,
6153
6154 /* semaphore is available */
6155 _POLL_STATE_SEM_AVAILABLE,
6156
6157 /* data is available to read on queue/FIFO/LIFO */
6158 _POLL_STATE_DATA_AVAILABLE,
6159
6160 /* queue/FIFO/LIFO wait was cancelled */
6161 _POLL_STATE_CANCELLED,
6162
6163 /* data is available to read on a message queue */
6164 _POLL_STATE_MSGQ_DATA_AVAILABLE,
6165
6166 /* data is available to read from a pipe */
6167 _POLL_STATE_PIPE_DATA_AVAILABLE,
6168
6169 _POLL_NUM_STATES
6170};
6171
6172#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
6173
6174#define _POLL_EVENT_NUM_UNUSED_BITS \
6175 (32 - (0 \
6176 + 8 /* tag */ \
6177 + _POLL_NUM_TYPES \
6178 + _POLL_NUM_STATES \
6179 + 1 /* modes */ \
6180 ))
6181
6182/* end of polling API - PRIVATE */
6183
6184
6192
6193/* Public polling API */
6194
6195/* public - values for k_poll_event.type bitfield */
6196#define K_POLL_TYPE_IGNORE 0
6197#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
6198#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
6199#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
6200#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
6201#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
6202#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
6203
6204/* public - polling modes */
6206 /* polling thread does not take ownership of objects when available */
6208
6210};
6211
6212/* public - values for k_poll_event.state bitfield */
6213#define K_POLL_STATE_NOT_READY 0
6214#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
6215#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
6216#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
6217#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
6218#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
6219#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
6220#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
6221
6222/* public - poll signal object */
6226
6231 unsigned int signaled;
6232
6235};
6236
6237#define K_POLL_SIGNAL_INITIALIZER(obj) \
6238 { \
6239 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
6240 .signaled = 0, \
6241 .result = 0, \
6242 }
6243
6249 sys_dnode_t _node;
6250
6252 struct z_poller *poller;
6253
6256
6258 uint32_t type:_POLL_NUM_TYPES;
6259
6261 uint32_t state:_POLL_NUM_STATES;
6262
6265
6267 uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
6268
6270 union {
6271 /* The typed_* fields below are used by K_POLL_EVENT_*INITIALIZER() macros to ensure
6272 * type safety of polled objects.
6273 */
6281 };
6282};
6283
6284#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
6285 { \
6286 .poller = NULL, \
6287 .type = _event_type, \
6288 .state = K_POLL_STATE_NOT_READY, \
6289 .mode = _event_mode, \
6290 .unused = 0, \
6291 { \
6292 .typed_##_event_type = _event_obj, \
6293 }, \
6294 }
6295
6296#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
6297 event_tag) \
6298 { \
6299 .tag = event_tag, \
6300 .type = _event_type, \
6301 .state = K_POLL_STATE_NOT_READY, \
6302 .mode = _event_mode, \
6303 .unused = 0, \
6304 { \
6305 .typed_##_event_type = _event_obj, \
6306 }, \
6307 }
6308
6323
6324void k_poll_event_init(struct k_poll_event *event, uint32_t type,
6325 int mode, void *obj);
6326
6369
6370__syscall int k_poll(struct k_poll_event *events, int num_events,
6371 k_timeout_t timeout);
6372
6380
6381__syscall void k_poll_signal_init(struct k_poll_signal *sig);
6382
6388__syscall void k_poll_signal_reset(struct k_poll_signal *sig);
6389
6400__syscall void k_poll_signal_check(struct k_poll_signal *sig,
6401 unsigned int *signaled, int *result);
6402
6426
6427__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);
6428
6430
6449static inline void k_cpu_idle(void)
6450{
6451 arch_cpu_idle();
6452}
6453
6468static inline void k_cpu_atomic_idle(unsigned int key)
6469{
6471}
6472
6476
6481#ifdef ARCH_EXCEPT
6482/* This architecture has direct support for triggering a CPU exception */
6483#define z_except_reason(reason) ARCH_EXCEPT(reason)
6484#else
6485
6486#if !defined(CONFIG_ASSERT_NO_FILE_INFO)
6487#define __EXCEPT_LOC() __ASSERT_PRINT("@ %s:%d\n", __FILE__, __LINE__)
6488#else
6489#define __EXCEPT_LOC()
6490#endif
6491
6492/* NOTE: This is the implementation for arches that do not implement
6493 * ARCH_EXCEPT() to generate a real CPU exception.
6494 *
6495 * We won't have a real exception frame to determine the PC value when
6496 * the oops occurred, so print file and line number before we jump into
6497 * the fatal error handler.
6498 */
6499#define z_except_reason(reason) do { \
6500 __EXCEPT_LOC(); \
6501 z_fatal_error(reason, NULL); \
6502 } while (false)
6503
6504#endif /* _ARCH__EXCEPT */
6508
6520#define k_oops() z_except_reason(K_ERR_KERNEL_OOPS)
6521
6530#define k_panic() z_except_reason(K_ERR_KERNEL_PANIC)
6531
6535
6536/*
6537 * private APIs that are utilized by one or more public APIs
6538 */
6539
6543void z_timer_expiration_handler(struct _timeout *timeout);
6547
6548#ifdef CONFIG_PRINTK
6556__syscall void k_str_out(char *c, size_t n);
6557#endif
6558
6564
6585__syscall int k_float_disable(struct k_thread *thread);
6586
6625__syscall int k_float_enable(struct k_thread *thread, unsigned int options);
6626
6630
6640
6648
6657
6668
6679
6688
6697
6698#ifdef __cplusplus
6699}
6700#endif
6701
6702#include <zephyr/tracing/tracing.h>
6703#include <zephyr/syscalls/kernel.h>
6704
6705#endif /* !_ASMLANGUAGE */
6706
6707#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:2053
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1454
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:2005
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:2034
static uint32_t k_uptime_seconds(void)
Get system uptime in seconds.
Definition kernel.h:2018
static uint64_t k_cycle_get_64(void)
Read the 64-bit hardware clock.
Definition kernel.h:2068
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:1981
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:6449
static void k_cpu_atomic_idle(unsigned int key)
Make the CPU idle in an atomic fashion.
Definition kernel.h:6468
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:2684
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.
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:5725
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:5742
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:5764
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:5382
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:5384
@ PIPE_FLAG_OPEN
Definition kernel.h:5383
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:6205
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:6207
@ K_POLL_NUM_MODES
Definition kernel.h:6209
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:375
#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:281
#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 absolute 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:506
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:600
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.
static void k_thread_runtime_stats_longest_frame_reset(__maybe_unused struct k_thread *thread)
Resets thread longest frame usage data for specified thread.
Definition kernel.h:120
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:734
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:1204
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 relative 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.
static bool k_is_pre_kernel(void)
Test whether startup is in the before-main-task phase.
Definition kernel.h:701
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:127
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:1756
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:1740
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:1905
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:4558
static bool k_work_is_pending(const struct k_work *work)
Test whether a work item is currently pending.
Definition kernel.h:4529
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:4546
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:4685
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:4662
void(* k_work_handler_t)(struct k_work *work)
The signature for a work item handler function.
Definition kernel.h:3701
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:4540
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:4640
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:4581
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:4740
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:4535
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:4552
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:4309
@ K_WORK_QUEUED
Flag indicating a work item that has been submitted to a queue but has not started running.
Definition kernel.h:4316
@ K_WORK_DELAYED
Flag indicating a delayed work item that is scheduled for submission to a queue.
Definition kernel.h:4323
@ K_WORK_RUNNING
Flag indicating a work item that is running under a work queue thread.
Definition kernel.h:4303
@ K_WORK_FLUSHING
Flag indicating a synced work item that is being flushed.
Definition kernel.h:4329
#define BUILD_ASSERT(EXPR, MSG...)
Definition llvm.h:51
struct k_thread * k_tid_t
Definition thread.h:368
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:3585
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:3612
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:3344
_wait_q_t wait_q
Definition kernel.h:3345
Event Structure.
Definition kernel.h:2461
Definition kernel.h:2704
futex structure
Definition kernel.h:2375
atomic_t val
Definition kernel.h:2376
Definition kernel.h:5809
struct k_spinlock lock
Definition kernel.h:5812
struct sys_heap heap
Definition kernel.h:5810
_wait_q_t wait_q
Definition kernel.h:5811
IPI work item structure.
Definition kernel.h:3593
Definition kernel.h:2944
Mailbox Message Structure.
Definition kernel.h:5219
k_tid_t tx_target_thread
target thread id
Definition kernel.h:5229
void * tx_data
sender's message data buffer
Definition kernel.h:5225
k_tid_t rx_source_thread
source thread id
Definition kernel.h:5227
uint32_t info
application-defined information value
Definition kernel.h:5223
size_t size
size of message (in bytes)
Definition kernel.h:5221
Mailbox Structure.
Definition kernel.h:5241
_wait_q_t tx_msg_queue
Transmit messages queue.
Definition kernel.h:5243
struct k_spinlock lock
Definition kernel.h:5246
_wait_q_t rx_msg_queue
Receive message queue.
Definition kernel.h:5245
Memory Domain.
Definition mem_domain.h:80
Memory Partition.
Definition mem_domain.h:55
Message Queue Attributes.
Definition kernel.h:4961
uint32_t used_msgs
Used messages.
Definition kernel.h:4967
size_t msg_size
Message Size.
Definition kernel.h:4963
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4965
Message Queue Structure.
Definition kernel.h:4900
size_t msg_size
Message size.
Definition kernel.h:4906
char * read_ptr
Read pointer.
Definition kernel.h:4914
uint32_t used_msgs
Number of used messages.
Definition kernel.h:4918
char * buffer_end
End of message buffer.
Definition kernel.h:4912
struct k_spinlock lock
Lock.
Definition kernel.h:4904
char * write_ptr
Write pointer.
Definition kernel.h:4916
char * buffer_start
Start of message buffer.
Definition kernel.h:4910
uint8_t flags
Message queue.
Definition kernel.h:4923
_wait_q_t wait_q
Message queue wait queue.
Definition kernel.h:4902
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:4908
Mutex Structure.
Definition kernel.h:3232
uint32_t lock_count
Current lock count.
Definition kernel.h:3239
_wait_q_t wait_q
Mutex wait queue.
Definition kernel.h:3234
int owner_orig_prio
Original thread priority.
Definition kernel.h:3242
struct k_thread * owner
Mutex owner.
Definition kernel.h:3236
Object core structure.
Definition obj_core.h:126
Definition kernel.h:5387
uint8_t flags
Definition kernel.h:5393
struct ring_buf buf
Definition kernel.h:5389
_wait_q_t data
Definition kernel.h:5391
_wait_q_t space
Definition kernel.h:5392
struct k_spinlock lock
Definition kernel.h:5390
size_t waiting
Definition kernel.h:5388
Poll Event.
Definition kernel.h:6247
struct k_msgq * typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE
Definition kernel.h:6279
void * typed_K_POLL_TYPE_IGNORE
Definition kernel.h:6274
struct k_poll_signal * signal
Definition kernel.h:6275
struct k_pipe * pipe
Definition kernel.h:6280
uint32_t tag
optional user-specified tag, opaque, untouched by the API
Definition kernel.h:6255
struct k_fifo * fifo
Definition kernel.h:6277
struct k_msgq * msgq
Definition kernel.h:6279
struct k_queue * queue
Definition kernel.h:6278
uint32_t unused
unused bits in 32-bit word
Definition kernel.h:6267
struct k_pipe * typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE
Definition kernel.h:6280
uint32_t type
bitfield of event types (bitwise-ORed K_POLL_TYPE_xxx values)
Definition kernel.h:6258
struct k_sem * sem
Definition kernel.h:6276
struct k_queue * typed_K_POLL_TYPE_DATA_AVAILABLE
Definition kernel.h:6278
struct k_sem * typed_K_POLL_TYPE_SEM_AVAILABLE
Definition kernel.h:6276
uint32_t state
bitfield of event states (bitwise-ORed K_POLL_STATE_xxx values)
Definition kernel.h:6261
uint32_t mode
mode of operation, from enum k_poll_modes
Definition kernel.h:6264
struct z_poller * poller
PRIVATE - DO NOT TOUCH.
Definition kernel.h:6252
struct k_poll_signal * typed_K_POLL_TYPE_SIGNAL
Definition kernel.h:6275
void * obj
Definition kernel.h:6274
struct k_fifo * typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE
Definition kernel.h:6277
Definition kernel.h:6223
sys_dlist_t poll_events
PRIVATE - DO NOT TOUCH.
Definition kernel.h:6225
int result
custom result value passed to k_poll_signal_raise() if needed
Definition kernel.h:6234
unsigned int signaled
1 if the event has been signaled, 0 otherwise.
Definition kernel.h:6231
Definition kernel.h:2083
struct k_spinlock lock
Definition kernel.h:2085
_wait_q_t wait_q
Definition kernel.h:2086
sys_sflist_t data_q
Definition kernel.h:2084
Semaphore structure.
Definition kernel.h:3437
Kernel Spin Lock.
Definition spinlock.h:45
Thread Structure.
Definition thread.h:252
struct _thread_base base
Definition thread.h:254
struct k_heap * resource_pool
resource pool
Definition thread.h:342
struct __thread_entry entry
thread entry and parameters description
Definition thread.h:281
Kernel timeout type.
Definition clock.h:65
Kernel timer structure.
Definition kernel.h:1662
A structure used to submit work after a delay.
Definition kernel.h:4361
struct _timeout timeout
Definition kernel.h:4366
struct k_work_q * queue
Definition kernel.h:4369
struct k_work work
Definition kernel.h:4363
A structure used to hold work until it can be processed.
Definition kernel.h:4495
sys_slist_t pending
Definition kernel.h:4509
_wait_q_t drainq
Definition kernel.h:4515
k_tid_t thread_id
Definition kernel.h:4502
_wait_q_t notifyq
Definition kernel.h:4512
uint32_t flags
Definition kernel.h:4518
struct k_thread thread
Definition kernel.h:4497
A structure holding optional configuration items for a work queue.
Definition kernel.h:4457
const char * name
The name to be given to the work queue thread.
Definition kernel.h:4462
uint32_t work_timeout_ms
Controls whether work queue monitors work timeouts.
Definition kernel.h:4491
bool essential
Control whether the work queue thread should be marked as essential thread.
Definition kernel.h:4481
bool no_yield
Control whether the work queue thread should yield between items.
Definition kernel.h:4476
A structure holding internal state for a pending synchronous operation on a work item or queue.
Definition kernel.h:4444
struct z_work_canceller canceller
Definition kernel.h:4447
struct z_work_flusher flusher
Definition kernel.h:4446
A structure used to submit work.
Definition kernel.h:4333
k_work_handler_t handler
Definition kernel.h:4342
uint32_t flags
Definition kernel.h:4353
struct k_work_q * queue
Definition kernel.h:4345
sys_snode_t node
Definition kernel.h:4339
A structure to represent a ring buffer.
Definition ring_buffer.h:50
Definition sys_heap.h:57
Definition mem_stats.h:24
static __pinned_func bool k_is_user_context(void)
Indicate whether the CPU is currently in user mode.
Definition syscall.h:115
Macros to abstract toolchain specific capabilities.
Main header file for tracing subsystem API.
Header file for tracing macros.