Zephyr API Documentation 4.5.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>
23#include <zephyr/sleep.h>
27
28#ifdef __cplusplus
29extern "C" {
30#endif
31
32/*
33 * Zephyr currently assumes the size of a couple standard types to simplify
34 * print string formats. Let's make sure this doesn't change without notice.
35 */
36BUILD_ASSERT(sizeof(int32_t) == sizeof(int));
37BUILD_ASSERT(sizeof(int64_t) == sizeof(long long));
38BUILD_ASSERT(sizeof(intptr_t) == sizeof(long));
39
48
57#define K_ANY NULL
58
59#if (CONFIG_NUM_COOP_PRIORITIES + CONFIG_NUM_PREEMPT_PRIORITIES) == 0
60#error Zero available thread priorities defined!
61#endif
62
67
78#define K_PRIO_COOP(x) (-(CONFIG_NUM_COOP_PRIORITIES - (x)))
79
90#define K_PRIO_PREEMPT(x) (x)
91
93#define K_HIGHEST_THREAD_PRIO (-CONFIG_NUM_COOP_PRIORITIES)
95#define K_LOWEST_THREAD_PRIO CONFIG_NUM_PREEMPT_PRIORITIES
97#define K_IDLE_PRIO K_LOWEST_THREAD_PRIO
99#define K_HIGHEST_APPLICATION_THREAD_PRIO (K_HIGHEST_THREAD_PRIO)
101#define K_LOWEST_APPLICATION_THREAD_PRIO (K_LOWEST_THREAD_PRIO - 1)
102
104
105#ifdef CONFIG_POLL
106#define Z_POLL_EVENT_OBJ_INIT(obj) \
107 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events),
108#define Z_DECL_POLL_EVENT sys_dlist_t poll_events;
109#else
110#define Z_POLL_EVENT_OBJ_INIT(obj)
111#define Z_DECL_POLL_EVENT
112#endif
113
114struct k_thread;
115struct k_mutex;
116struct k_sem;
117struct k_msgq;
118struct k_mbox;
119struct k_pipe;
120struct k_queue;
121struct k_fifo;
122struct k_lifo;
123struct k_stack;
124struct k_mem_slab;
125struct k_timer;
126struct k_poll_event;
127struct k_poll_signal;
128struct k_mem_domain;
129struct k_mem_partition;
130struct k_futex;
131struct k_event;
132
143
144/* private, used by k_poll and k_work_poll */
145struct k_work_poll;
146typedef int (*_poller_cb_t)(struct k_poll_event *event, uint32_t state);
147
152
166static inline void
168{
169#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
170 thread->base.usage.longest = 0ULL;
171#endif
172}
173
180typedef void (*k_thread_user_cb_t)(const struct k_thread *thread,
181 void *user_data);
182
198void k_thread_foreach(k_thread_user_cb_t user_cb, void *user_data);
199
218#ifdef CONFIG_SMP
219void k_thread_foreach_filter_by_cpu(unsigned int cpu,
220 k_thread_user_cb_t user_cb, void *user_data);
221#else
222static inline
223void k_thread_foreach_filter_by_cpu(unsigned int cpu,
224 k_thread_user_cb_t user_cb, void *user_data)
225{
226 __ASSERT(cpu == 0, "cpu filter out of bounds");
227 ARG_UNUSED(cpu);
228 k_thread_foreach(user_cb, user_data);
229}
230#endif
231
260 k_thread_user_cb_t user_cb, void *user_data);
261
293#ifdef CONFIG_SMP
295 k_thread_user_cb_t user_cb, void *user_data);
296#else
297static inline
298void k_thread_foreach_unlocked_filter_by_cpu(unsigned int cpu,
299 k_thread_user_cb_t user_cb, void *user_data)
300{
301 __ASSERT(cpu == 0, "cpu filter out of bounds");
302 ARG_UNUSED(cpu);
303 k_thread_foreach_unlocked(user_cb, user_data);
304}
305#endif
306
308
314
315#endif /* !_ASMLANGUAGE */
316
317
318/*
319 * Thread user options. May be needed by assembly code. Common part uses low
320 * bits, arch-specific use high bits.
321 */
322
326#define K_ESSENTIAL (BIT(0))
327
331#define K_FP_IDX 1
344#define K_FP_REGS (BIT(K_FP_IDX))
345
352#define K_USER (BIT(2))
353
362#define K_INHERIT_PERMS (BIT(3))
363
373#define K_CALLBACK_STATE (BIT(4))
374
378#define K_DSP_IDX 13
391#define K_DSP_REGS (BIT(K_DSP_IDX))
392
396#define K_AGU_IDX 14
408#define K_AGU_REGS (BIT(K_AGU_IDX))
409
419#define K_SSE_REGS (BIT(15))
420
421/* end - thread options */
422
423#if !defined(_ASMLANGUAGE)
448__syscall k_thread_stack_t *k_thread_stack_alloc(size_t size, int flags);
449
463
515__syscall k_tid_t k_thread_create(struct k_thread *new_thread,
516 k_thread_stack_t *stack,
517 size_t stack_size,
519 void *p1, void *p2, void *p3,
520 int prio, uint32_t options, k_timeout_t delay);
521
544 void *p1, void *p2,
545 void *p3);
546
560#define k_thread_access_grant(thread, ...) \
561 FOR_EACH_FIXED_ARG(k_object_access_grant, (;), (thread), __VA_ARGS__)
562
577static inline void k_thread_heap_assign(struct k_thread *thread,
578 struct k_heap *heap)
579{
580 thread->resource_pool = heap;
581}
582
583#if defined(CONFIG_INIT_STACKS) && defined(CONFIG_THREAD_STACK_INFO)
605__syscall int k_thread_stack_space_get(const struct k_thread *thread,
606 size_t *unused_ptr);
607
623__syscall int k_thread_runtime_stack_unused_threshold_pct_set(struct k_thread *thread,
624 uint32_t pct);
625
641__syscall int k_thread_runtime_stack_unused_threshold_set(struct k_thread *thread,
642 size_t threshold);
643
656__syscall size_t k_thread_runtime_stack_unused_threshold_get(struct k_thread *thread);
657
669typedef void (*k_thread_stack_safety_handler_t)(const struct k_thread *thread,
670 size_t unused_space, void *arg);
671
686int k_thread_runtime_stack_safety_full_check(const struct k_thread *thread,
687 size_t *unused_ptr,
688 k_thread_stack_safety_handler_t handler,
689 void *arg);
690
705int k_thread_runtime_stack_safety_threshold_check(const struct k_thread *thread,
706 size_t *unused_ptr,
707 k_thread_stack_safety_handler_t handler,
708 void *arg);
709#endif
710
711#if (K_HEAP_MEM_POOL_SIZE > 0)
724void k_thread_system_pool_assign(struct k_thread *thread);
725#endif /* (K_HEAP_MEM_POOL_SIZE > 0) */
726
746__syscall int k_thread_join(struct k_thread *thread, k_timeout_t timeout);
747
764__syscall void k_busy_wait(uint32_t usec_to_wait);
765
777bool k_can_yield(void);
778
786__syscall void k_yield(void);
787
797__syscall void k_wakeup(k_tid_t thread);
798
812__attribute_const__
814
826static inline bool k_is_pre_kernel(void)
827{
828 extern bool z_sys_post_kernel; /* in init.c */
829
830 /*
831 * If called from userspace, it must be post kernel.
832 * This guard is necessary because z_sys_post_kernel memory
833 * is not accessible to user threads.
834 */
835 if (k_is_user_context()) {
836 return false;
837 }
838
839 /*
840 * Some compilers might optimize by pre-reading
841 * z_sys_post_kernel. This is absolutely not desirable.
842 * We are trying to avoid reading it if we are in user
843 * context as reading z_sys_post_kernel in user context
844 * will result in access fault. So add a compiler barrier
845 * here to stop that kind of optimizations.
846 */
847 compiler_barrier();
848
849 return !z_sys_post_kernel;
850}
851
858__attribute_const__
859static inline k_tid_t k_current_get(void)
860{
861 __ASSERT(!k_is_pre_kernel(), "k_current_get called pre-kernel");
862
863#ifdef CONFIG_CURRENT_THREAD_USE_TLS
864
865 /* Thread-local cache of current thread ID, set in z_thread_entry() */
866 extern Z_THREAD_LOCAL k_tid_t z_tls_current;
867
868 return z_tls_current;
869#else
871#endif
872}
873
884static inline bool k_thread_is_user_thread(const struct k_thread *thread)
885{
886 return (thread->base.user_options & K_USER) != 0U;
887}
888
909__syscall void k_thread_abort(k_tid_t thread);
910
911k_ticks_t z_timeout_expires(const struct _timeout *timeout);
912k_ticks_t z_timeout_remaining(const struct _timeout *timeout);
913
914#ifdef CONFIG_SYS_CLOCK_EXISTS
915
923__syscall k_ticks_t k_thread_timeout_expires_ticks(const struct k_thread *thread);
924
925static inline k_ticks_t z_impl_k_thread_timeout_expires_ticks(
926 const struct k_thread *thread)
927{
928 return z_timeout_expires(&thread->base.timeout);
929}
930
939
940static inline k_ticks_t z_impl_k_thread_timeout_remaining_ticks(
941 const struct k_thread *thread)
942{
943 return z_timeout_remaining(&thread->base.timeout);
944}
945
946#endif /* CONFIG_SYS_CLOCK_EXISTS */
947
951struct _static_thread_data {
952 struct k_thread *init_thread;
953 k_thread_stack_t *init_stack;
954 unsigned int init_stack_size;
955 k_thread_entry_t init_entry;
956 void *init_p1;
957 void *init_p2;
958 void *init_p3;
959 int init_prio;
960 uint32_t init_options;
961 const char *init_name;
962#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
963 int32_t init_delay_ms;
964#else
965 k_timeout_t init_delay;
966#endif
967};
968
969#ifdef CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME
970#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay_ms = (ms)
971#define Z_THREAD_INIT_DELAY(thread) SYS_TIMEOUT_MS((thread)->init_delay_ms)
972#else
973#define Z_THREAD_INIT_DELAY_INITIALIZER(ms) .init_delay = SYS_TIMEOUT_MS(ms)
974#define Z_THREAD_INIT_DELAY(thread) (thread)->init_delay
975#endif
976
977#define Z_THREAD_INITIALIZER(thread, stack, stack_size, \
978 entry, p1, p2, p3, \
979 prio, options, delay, tname) \
980 { \
981 .init_thread = (thread), \
982 .init_stack = (stack), \
983 .init_stack_size = (stack_size), \
984 .init_entry = (k_thread_entry_t)entry, \
985 .init_p1 = (void *)p1, \
986 .init_p2 = (void *)p2, \
987 .init_p3 = (void *)p3, \
988 .init_prio = (prio), \
989 .init_options = (options), \
990 .init_name = STRINGIFY(tname), \
991 Z_THREAD_INIT_DELAY_INITIALIZER(delay) \
992 }
993
994/*
995 * Refer to K_THREAD_DEFINE() and K_KERNEL_THREAD_DEFINE() for
996 * information on arguments.
997 */
998#define Z_THREAD_COMMON_DEFINE(name, stack_size, \
999 entry, p1, p2, p3, \
1000 prio, options, delay) \
1001 struct k_thread _k_thread_obj_##name; \
1002 const STRUCT_SECTION_ITERABLE(_static_thread_data, \
1003 _k_thread_data_##name) = \
1004 Z_THREAD_INITIALIZER(&_k_thread_obj_##name, \
1005 _k_thread_stack_##name, stack_size,\
1006 entry, p1, p2, p3, prio, options, \
1007 delay, name); \
1008 __maybe_unused const k_tid_t name = (k_tid_t)&_k_thread_obj_##name
1012
1044#define K_THREAD_DEFINE(name, stack_size, \
1045 entry, p1, p2, p3, \
1046 prio, options, delay) \
1047 K_THREAD_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
1048 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
1049 prio, options, delay)
1050
1081#define K_KERNEL_THREAD_DEFINE(name, stack_size, \
1082 entry, p1, p2, p3, \
1083 prio, options, delay) \
1084 K_KERNEL_STACK_DEFINE(_k_thread_stack_##name, stack_size); \
1085 Z_THREAD_COMMON_DEFINE(name, stack_size, entry, p1, p2, p3, \
1086 prio, options, delay)
1087
1097__syscall int k_thread_priority_get(k_tid_t thread);
1098
1124__syscall void k_thread_priority_set(k_tid_t thread, int prio);
1125
1126
1127#ifdef CONFIG_SCHED_DEADLINE
1163__syscall void k_thread_deadline_set(k_tid_t thread, int deadline);
1164
1205__syscall void k_thread_absolute_deadline_set(k_tid_t thread, int deadline);
1206#endif
1207
1226__syscall void k_reschedule(void);
1227
1228#ifdef CONFIG_SCHED_CPU_MASK
1246
1265
1281
1300
1311int k_thread_cpu_pin(k_tid_t thread, int cpu);
1312#endif
1313
1335__syscall void k_thread_suspend(k_tid_t thread);
1336
1348__syscall void k_thread_resume(k_tid_t thread);
1349
1363static inline void k_thread_start(k_tid_t thread)
1364{
1365 k_wakeup(thread);
1366}
1367
1394void k_sched_time_slice_set(int32_t slice, int prio);
1395
1434void k_thread_time_slice_set(struct k_thread *th, int32_t slice_ticks,
1435 k_thread_timeslice_fn_t expired, void *data);
1436
1438
1443
1455bool k_is_in_isr(void);
1456
1473__syscall int k_is_preempt_thread(void);
1474
1478
1483
1509void k_sched_lock(void);
1510
1519
1532__syscall void k_thread_custom_data_set(void *value);
1533
1541__syscall void *k_thread_custom_data_get(void);
1542
1559__syscall int k_thread_name_set(k_tid_t thread, const char *str);
1560
1569const char *k_thread_name_get(k_tid_t thread);
1570
1583__syscall int k_thread_name_copy(k_tid_t thread, char *buf,
1584 size_t size);
1585
1598const char *k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size);
1599
1603
1608
1617#define K_NO_WAIT Z_TIMEOUT_NO_WAIT
1618
1631#define K_NSEC(t) Z_TIMEOUT_NS(t)
1632
1645#define K_USEC(t) Z_TIMEOUT_US(t)
1646
1657#define K_CYC(t) Z_TIMEOUT_CYC(t)
1658
1669#define K_TICKS(t) Z_TIMEOUT_TICKS(t)
1670
1681#define K_MSEC(ms) Z_TIMEOUT_MS(ms)
1682
1693#define K_SECONDS(s) K_MSEC((s) * MSEC_PER_SEC)
1694
1705#define K_MINUTES(m) K_SECONDS((m) * 60)
1706
1717#define K_HOURS(h) K_MINUTES((h) * 60)
1718
1727#define K_FOREVER Z_FOREVER
1728
1743#define K_TIMEOUT_SUM(timeout1, timeout2) K_TICKS(z_timeout_sum(timeout1, timeout2))
1744
1745#ifdef CONFIG_TIMEOUT_64BIT
1746
1758#define K_TIMEOUT_ABS_TICKS(t) \
1759 Z_TIMEOUT_TICKS(Z_TICK_ABS((k_ticks_t)CLAMP(t, 0, (INT64_MAX - 1))))
1760
1772#define K_TIMEOUT_ABS_SEC(t) K_TIMEOUT_ABS_TICKS(k_sec_to_ticks_ceil64(t))
1773
1785#define K_TIMEOUT_ABS_MS(t) K_TIMEOUT_ABS_TICKS(k_ms_to_ticks_ceil64(t))
1786
1799#define K_TIMEOUT_ABS_US(t) K_TIMEOUT_ABS_TICKS(k_us_to_ticks_ceil64(t))
1800
1813#define K_TIMEOUT_ABS_NS(t) K_TIMEOUT_ABS_TICKS(k_ns_to_ticks_ceil64(t))
1814
1827#define K_TIMEOUT_ABS_CYC(t) K_TIMEOUT_ABS_TICKS(k_cyc_to_ticks_ceil64(t))
1828#endif
1829
1833
1840struct k_timer {
1844 /*
1845 * _timeout structure must be first here if we want to use
1846 * dynamic timer allocation. timeout.node is used in the double-linked
1847 * list of free timers
1848 */
1849 struct _timeout timeout;
1850
1851 /* wait queue for the (single) thread waiting on this timer */
1852 _wait_q_t wait_q;
1853
1854 /* runs in ISR context */
1855 void (*expiry_fn)(struct k_timer *timer);
1856
1857 /* runs in the context of the thread that calls k_timer_stop() */
1858 void (*stop_fn)(struct k_timer *timer);
1859
1860 /* timer period */
1861 k_timeout_t period;
1862
1863 /* timer status */
1864 uint32_t status;
1865
1866 /* user-specific data, also used to support legacy features */
1867 void *user_data;
1868
1869#ifdef CONFIG_OBJ_CORE_TIMER
1870 struct k_obj_core obj_core;
1871#endif
1875};
1876
1877#ifdef CONFIG_TIMER_OBSERVER
1878struct k_timer_observer {
1879 /* Invoked upon completion of k_timer initialization */
1880 void (*on_init)(struct k_timer *timer);
1881
1882 /* Invoked after the timer transitions to the running state */
1883 void (*on_start)(struct k_timer *timer, k_timeout_t duration,
1884 k_timeout_t period);
1885
1886 /* Invoked when the active timer is explicitly stopped */
1887 void (*on_stop)(struct k_timer *timer);
1888
1889 /* Executes in ISR context, keep minimal and non-blocking */
1890 void (*on_expiry)(struct k_timer *timer);
1891};
1892#endif /* CONFIG_TIMER_OBSERVER */
1893
1897#define Z_TIMER_INITIALIZER(obj, expiry, stop) \
1898 { \
1899 .timeout = { \
1900 .fn = z_timer_expiration_handler, \
1901 }, \
1902 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
1903 .expiry_fn = expiry, \
1904 .stop_fn = stop, \
1905 .period = {}, \
1906 .status = 0, \
1907 .user_data = 0, \
1908 }
1912
1918
1929typedef void (*k_timer_expiry_t)(struct k_timer *timer);
1930
1945typedef void (*k_timer_stop_t)(struct k_timer *timer);
1946
1958#define K_TIMER_DEFINE(name, expiry_fn, stop_fn) \
1959 STRUCT_SECTION_ITERABLE(k_timer, name) = \
1960 Z_TIMER_INITIALIZER(name, expiry_fn, stop_fn)
1961
1962
1963#ifdef CONFIG_TIMER_OBSERVER
1964
1968#define Z_TIMER_OBSERVER_INITIALIZER(name, init, start, stop, expiry) \
1969 { \
1970 .on_init = init, \
1971 .on_start = start, \
1972 .on_stop = stop, \
1973 .on_expiry = expiry \
1974 }
1978
1992#define K_TIMER_OBSERVER_DEFINE(name, init, start, stop, expiry) \
1993 static const STRUCT_SECTION_ITERABLE(k_timer_observer, name) = \
1994 Z_TIMER_OBSERVER_INITIALIZER(name, init, start, stop, expiry)
1995
1996#endif /* CONFIG_TIMER_OBSERVER */
1997
2007void k_timer_init(struct k_timer *timer,
2008 k_timer_expiry_t expiry_fn,
2009 k_timer_stop_t stop_fn);
2010
2028__syscall void k_timer_start(struct k_timer *timer,
2029 k_timeout_t duration, k_timeout_t period);
2030
2047__syscall void k_timer_stop(struct k_timer *timer);
2048
2061__syscall uint32_t k_timer_status_get(struct k_timer *timer);
2062
2080__syscall uint32_t k_timer_status_sync(struct k_timer *timer);
2081
2082#ifdef CONFIG_SYS_CLOCK_EXISTS
2083
2095__syscall k_ticks_t k_timer_expires_ticks(const struct k_timer *timer);
2096
2097static inline k_ticks_t z_impl_k_timer_expires_ticks(
2098 const struct k_timer *timer)
2099{
2100 return z_timeout_expires(&timer->timeout);
2101}
2102
2113__syscall k_ticks_t k_timer_remaining_ticks(const struct k_timer *timer);
2114
2115static inline k_ticks_t z_impl_k_timer_remaining_ticks(
2116 const struct k_timer *timer)
2117{
2118 return z_timeout_remaining(&timer->timeout);
2119}
2120
2131static inline uint32_t k_timer_remaining_get(struct k_timer *timer)
2132{
2134}
2135
2136#endif /* CONFIG_SYS_CLOCK_EXISTS */
2137
2150__syscall void k_timer_user_data_set(struct k_timer *timer, void *user_data);
2151
2155static inline void z_impl_k_timer_user_data_set(struct k_timer *timer,
2156 void *user_data)
2157{
2158 timer->user_data = user_data;
2159}
2160
2168__syscall void *k_timer_user_data_get(const struct k_timer *timer);
2169
2170static inline void *z_impl_k_timer_user_data_get(const struct k_timer *timer)
2171{
2172 return timer->user_data;
2173}
2174
2195int k_timer_cleanup(struct k_timer *timer);
2196
2198
2204
2214__syscall int64_t k_uptime_ticks(void);
2215
2229static inline int64_t k_uptime_get(void)
2230{
2232}
2233
2253static inline uint32_t k_uptime_get_32(void)
2254{
2255 return (uint32_t)k_uptime_get();
2256}
2257
2266static inline uint32_t k_uptime_seconds(void)
2267{
2269}
2270
2282static inline int64_t k_uptime_delta(int64_t *reftime)
2283{
2284 int64_t uptime, delta;
2285
2286 uptime = k_uptime_get();
2287 delta = uptime - *reftime;
2288 *reftime = uptime;
2289
2290 return delta;
2291}
2292
2301static inline uint32_t k_cycle_get_32(void)
2302{
2303 return arch_k_cycle_get_32();
2304}
2305
2319static inline uint64_t k_cycle_get_64(void)
2320{
2321 if (!IS_ENABLED(CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER)) {
2322 __ASSERT(0, "64-bit cycle counter not enabled on this platform. "
2323 "See CONFIG_TIMER_HAS_64BIT_CYCLE_COUNTER");
2324 return 0;
2325 }
2326
2327 return arch_k_cycle_get_64();
2328}
2329
2333
2340struct k_queue {
2344 sys_sflist_t data_q;
2345 struct k_spinlock lock;
2346 _wait_q_t wait_q;
2347
2348 Z_DECL_POLL_EVENT
2349
2350#ifdef CONFIG_OBJ_CORE_QUEUE
2351 struct k_obj_core obj_core;
2352#endif
2356};
2357
2361#define Z_QUEUE_INITIALIZER(obj) \
2362 { \
2363 .data_q = SYS_SFLIST_STATIC_INIT(&obj.data_q), \
2364 .lock = { }, \
2365 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2366 Z_POLL_EVENT_OBJ_INIT(obj) \
2367 }
2371
2395
2407__syscall void k_queue_init(struct k_queue *queue);
2408
2426__syscall void k_queue_cancel_wait(struct k_queue *queue);
2427
2450void k_queue_append(struct k_queue *queue, void *data);
2451
2485__syscall int32_t k_queue_alloc_append(struct k_queue *queue, void *data);
2486
2509void k_queue_prepend(struct k_queue *queue, void *data);
2510
2544__syscall int32_t k_queue_alloc_prepend(struct k_queue *queue, void *data);
2545
2579void k_queue_insert(struct k_queue *queue, void *prev, void *data);
2580
2604int k_queue_append_list(struct k_queue *queue, void *head, void *tail);
2605
2626int k_queue_merge_slist(struct k_queue *queue, sys_slist_t *list);
2627
2654__syscall void *k_queue_get(struct k_queue *queue, k_timeout_t timeout);
2655
2677bool k_queue_remove(struct k_queue *queue, void *data);
2678
2705bool k_queue_unique_append(struct k_queue *queue, void *data);
2706
2720__syscall int k_queue_is_empty(struct k_queue *queue);
2721
2722static inline int z_impl_k_queue_is_empty(struct k_queue *queue)
2723{
2724 return sys_sflist_is_empty(&queue->data_q) ? 1 : 0;
2725}
2726
2739__syscall void *k_queue_peek_head(struct k_queue *queue);
2740
2753__syscall void *k_queue_peek_tail(struct k_queue *queue);
2754
2764#define K_QUEUE_DEFINE(name) \
2765 STRUCT_SECTION_ITERABLE(k_queue, name) = \
2766 Z_QUEUE_INITIALIZER(name)
2767
2769
2770#ifdef CONFIG_USERSPACE
2780struct k_futex {
2787};
2788
2794
2813__syscall int k_futex_wait(struct k_futex *futex, atomic_val_t expected, k_timeout_t timeout);
2814
2828__syscall int k_futex_wake(struct k_futex *futex, bool wake_all);
2829
2831#endif
2832
2838
2843
2850
2851struct k_event {
2855 _wait_q_t wait_q;
2856 uint32_t events;
2857 struct k_spinlock lock;
2858
2859#ifdef CONFIG_OBJ_CORE_EVENT
2860 struct k_obj_core obj_core;
2861#endif
2865};
2866
2870#define Z_EVENT_INITIALIZER(obj) \
2871 { \
2872 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
2873 .events = 0, \
2874 .lock = {}, \
2875 }
2879
2887__syscall void k_event_init(struct k_event *event);
2888
2907__syscall uint32_t k_event_post(struct k_event *event, uint32_t events);
2908
2926__syscall uint32_t k_event_set(struct k_event *event, uint32_t events);
2927
2944__syscall uint32_t k_event_set_masked(struct k_event *event, uint32_t events,
2945 uint32_t events_mask);
2946
2960__syscall uint32_t k_event_clear(struct k_event *event, uint32_t events);
2961
2989__syscall uint32_t k_event_wait(struct k_event *event, uint32_t events,
2990 bool reset, k_timeout_t timeout);
2991
3019__syscall uint32_t k_event_wait_all(struct k_event *event, uint32_t events,
3020 bool reset, k_timeout_t timeout);
3021
3044__syscall uint32_t k_event_wait_safe(struct k_event *event, uint32_t events,
3045 bool reset, k_timeout_t timeout);
3046
3069__syscall uint32_t k_event_wait_all_safe(struct k_event *event, uint32_t events,
3070 bool reset, k_timeout_t timeout);
3071
3082static inline uint32_t k_event_test(struct k_event *event, uint32_t events_mask)
3083{
3084 return k_event_wait(event, events_mask, false, K_NO_WAIT);
3085}
3086
3096#define K_EVENT_DEFINE(name) \
3097 STRUCT_SECTION_ITERABLE(k_event, name) = \
3098 Z_EVENT_INITIALIZER(name);
3099
3101
3107struct k_fifo {
3111 struct k_queue _queue;
3112#ifdef CONFIG_OBJ_CORE_FIFO
3113 struct k_obj_core obj_core;
3114#endif
3118};
3119
3123#define Z_FIFO_INITIALIZER(obj) \
3124 { \
3125 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
3126 }
3130
3145
3157#define k_fifo_init(fifo) \
3158 ({ \
3159 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, init, fifo); \
3160 k_queue_init(&(fifo)->_queue); \
3161 K_OBJ_CORE_INIT(K_OBJ_CORE(fifo), _obj_type_fifo); \
3162 K_OBJ_CORE_LINK(K_OBJ_CORE(fifo)); \
3163 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, init, fifo); \
3164 })
3165
3181#define k_fifo_cancel_wait(fifo) \
3182 ({ \
3183 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, cancel_wait, fifo); \
3184 k_queue_cancel_wait(&(fifo)->_queue); \
3185 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, cancel_wait, fifo); \
3186 })
3187
3209#define k_fifo_put(fifo, data) \
3210 ({ \
3211 void *_data = data; \
3212 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put, fifo, _data); \
3213 k_queue_append(&(fifo)->_queue, _data); \
3214 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put, fifo, _data); \
3215 })
3216
3249#define k_fifo_alloc_put(fifo, data) \
3250 ({ \
3251 void *_data = data; \
3252 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, alloc_put, fifo, _data); \
3253 int fap_ret = k_queue_alloc_append(&(fifo)->_queue, _data); \
3254 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, alloc_put, fifo, _data, fap_ret); \
3255 fap_ret; \
3256 })
3257
3280#define k_fifo_put_list(fifo, head, tail) \
3281 ({ \
3282 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_list, fifo, head, tail); \
3283 k_queue_append_list(&(fifo)->_queue, head, tail); \
3284 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_list, fifo, head, tail); \
3285 })
3286
3307#define k_fifo_put_slist(fifo, list) \
3308 ({ \
3309 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, put_slist, fifo, list); \
3310 k_queue_merge_slist(&(fifo)->_queue, list); \
3311 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, put_slist, fifo, list); \
3312 })
3313
3340#define k_fifo_get(fifo, timeout) \
3341 ({ \
3342 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, get, fifo, timeout); \
3343 void *fg_ret = k_queue_get(&(fifo)->_queue, timeout); \
3344 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, get, fifo, timeout, fg_ret); \
3345 fg_ret; \
3346 })
3347
3361#define k_fifo_is_empty(fifo) \
3362 k_queue_is_empty(&(fifo)->_queue)
3363
3380#define k_fifo_peek_head(fifo) \
3381 ({ \
3382 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_head, fifo); \
3383 void *fph_ret = k_queue_peek_head(&(fifo)->_queue); \
3384 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_head, fifo, fph_ret); \
3385 fph_ret; \
3386 })
3387
3402#define k_fifo_peek_tail(fifo) \
3403 ({ \
3404 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_fifo, peek_tail, fifo); \
3405 void *fpt_ret = k_queue_peek_tail(&(fifo)->_queue); \
3406 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_fifo, peek_tail, fifo, fpt_ret); \
3407 fpt_ret; \
3408 })
3409
3419#define K_FIFO_DEFINE(name) \
3420 STRUCT_SECTION_ITERABLE(k_fifo, name) = \
3421 Z_FIFO_INITIALIZER(name)
3422
3424
3430struct k_lifo {
3434 struct k_queue _queue;
3435#ifdef CONFIG_OBJ_CORE_LIFO
3436 struct k_obj_core obj_core;
3437#endif
3441};
3442
3446#define Z_LIFO_INITIALIZER(obj) \
3447 { \
3448 ._queue = Z_QUEUE_INITIALIZER(obj._queue) \
3449 }
3453
3465
3477#define k_lifo_init(lifo) \
3478 ({ \
3479 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, init, lifo); \
3480 k_queue_init(&(lifo)->_queue); \
3481 K_OBJ_CORE_INIT(K_OBJ_CORE(lifo), _obj_type_lifo); \
3482 K_OBJ_CORE_LINK(K_OBJ_CORE(lifo)); \
3483 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, init, lifo); \
3484 })
3485
3507#define k_lifo_put(lifo, data) \
3508 ({ \
3509 void *_data = data; \
3510 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, put, lifo, _data); \
3511 k_queue_prepend(&(lifo)->_queue, _data); \
3512 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, put, lifo, _data); \
3513 })
3514
3547#define k_lifo_alloc_put(lifo, data) \
3548 ({ \
3549 void *_data = data; \
3550 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, alloc_put, lifo, _data); \
3551 int lap_ret = k_queue_alloc_prepend(&(lifo)->_queue, _data); \
3552 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, alloc_put, lifo, _data, lap_ret); \
3553 lap_ret; \
3554 })
3555
3582#define k_lifo_get(lifo, timeout) \
3583 ({ \
3584 SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_lifo, get, lifo, timeout); \
3585 void *lg_ret = k_queue_get(&(lifo)->_queue, timeout); \
3586 SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_lifo, get, lifo, timeout, lg_ret); \
3587 lg_ret; \
3588 })
3589
3599#define K_LIFO_DEFINE(name) \
3600 STRUCT_SECTION_ITERABLE(k_lifo, name) = \
3601 Z_LIFO_INITIALIZER(name)
3602
3604
3608#define K_STACK_FLAG_ALLOC ((uint8_t)1) /* Buffer was allocated */
3609
3610typedef uintptr_t stack_data_t;
3611
3612struct k_stack {
3613 _wait_q_t wait_q;
3614 struct k_spinlock lock;
3615 stack_data_t *base, *next, *top;
3616
3617 uint8_t flags;
3618
3619#ifdef CONFIG_OBJ_CORE_STACK
3620 struct k_obj_core obj_core;
3621#endif
3622};
3623
3624#define Z_STACK_INITIALIZER(obj, stack_buffer, stack_num_entries) \
3625 { \
3626 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3627 .base = (stack_buffer), \
3628 .next = (stack_buffer), \
3629 .top = (stack_buffer) + (stack_num_entries), \
3630 }
3634
3640
3650void k_stack_init(struct k_stack *stack,
3651 stack_data_t *buffer, uint32_t num_entries);
3652
3653
3668
3669__syscall int32_t k_stack_alloc_init(struct k_stack *stack,
3670 uint32_t num_entries);
3671
3683int k_stack_cleanup(struct k_stack *stack);
3684
3698__syscall int k_stack_push(struct k_stack *stack, stack_data_t data);
3699
3720__syscall int k_stack_pop(struct k_stack *stack, stack_data_t *data,
3721 k_timeout_t timeout);
3722
3733#define K_STACK_DEFINE(name, stack_num_entries) \
3734 stack_data_t __noinit \
3735 _k_stack_buf_##name[stack_num_entries]; \
3736 STRUCT_SECTION_ITERABLE(k_stack, name) = \
3737 Z_STACK_INITIALIZER(name, _k_stack_buf_##name, \
3738 stack_num_entries)
3739
3741
3745struct k_work;
3746struct k_work_q;
3747struct k_work_queue_config;
3748extern struct k_work_q k_sys_work_q;
3752
3758
3764struct k_mutex {
3769 _wait_q_t wait_q;
3771 struct k_thread *owner;
3772
3774 uint32_t lock_count;
3775
3776#if Z_MUTEX_PI_ENABLED
3778 sys_snode_t held_node;
3779#endif /* Z_MUTEX_PI_ENABLED */
3780
3781#ifdef CONFIG_OBJ_CORE_MUTEX
3782 struct k_obj_core obj_core;
3783#endif
3787};
3788
3792#if Z_MUTEX_PI_ENABLED
3793#define Z_MUTEX_HELD_NODE_INIT .held_node = {NULL},
3794#else
3795#define Z_MUTEX_HELD_NODE_INIT
3796#endif
3797
3798#define Z_MUTEX_INITIALIZER(obj) \
3799 { \
3800 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
3801 .owner = NULL, \
3802 .lock_count = 0, \
3803 Z_MUTEX_HELD_NODE_INIT \
3804 }
3808
3818#define K_MUTEX_DEFINE(name) \
3819 STRUCT_SECTION_ITERABLE(k_mutex, name) = \
3820 Z_MUTEX_INITIALIZER(name)
3821
3834__syscall int k_mutex_init(struct k_mutex *mutex);
3835
3836
3864__syscall int k_mutex_lock(struct k_mutex *mutex, k_timeout_t timeout);
3865
3886__syscall int k_mutex_unlock(struct k_mutex *mutex);
3887
3891
3901 _wait_q_t wait_q;
3902
3903#ifdef CONFIG_OBJ_CORE_CONDVAR
3904 struct k_obj_core obj_core;
3905#endif
3909};
3910
3914#define Z_CONDVAR_INITIALIZER(obj) \
3915 { \
3916 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
3917 }
3921
3927
3934__syscall int k_condvar_init(struct k_condvar *condvar);
3935
3942__syscall int k_condvar_signal(struct k_condvar *condvar);
3943
3951__syscall int k_condvar_broadcast(struct k_condvar *condvar);
3952
3970__syscall int k_condvar_wait(struct k_condvar *condvar, struct k_mutex *mutex,
3971 k_timeout_t timeout);
3972
3983#define K_CONDVAR_DEFINE(name) \
3984 STRUCT_SECTION_ITERABLE(k_condvar, name) = \
3985 Z_CONDVAR_INITIALIZER(name)
3986
3989
3995
4002struct k_sem {
4006 _wait_q_t wait_q;
4007 unsigned int count;
4008 unsigned int limit;
4009
4010 Z_DECL_POLL_EVENT
4011
4012#ifdef CONFIG_OBJ_CORE_SEM
4013 struct k_obj_core obj_core;
4014#endif
4018};
4019
4023#define Z_SEM_INITIALIZER(obj, initial_count, count_limit) \
4024 { \
4025 .wait_q = Z_WAIT_Q_INIT(&(obj).wait_q), \
4026 .count = (initial_count), \
4027 .limit = (count_limit), \
4028 Z_POLL_EVENT_OBJ_INIT(obj) \
4029 }
4033
4042#define K_SEM_MAX_LIMIT UINT_MAX
4043
4059__syscall int k_sem_init(struct k_sem *sem, unsigned int initial_count,
4060 unsigned int limit);
4061
4080__syscall int k_sem_take(struct k_sem *sem, k_timeout_t timeout);
4081
4092__syscall void k_sem_give(struct k_sem *sem);
4093
4106__syscall void k_sem_reset(struct k_sem *sem);
4107
4117__syscall unsigned int k_sem_count_get(struct k_sem *sem);
4118
4122static inline unsigned int z_impl_k_sem_count_get(struct k_sem *sem)
4123{
4124 return sem->count;
4125}
4126
4138#define K_SEM_DEFINE(name, initial_count, count_limit) \
4139 STRUCT_SECTION_ITERABLE(k_sem, name) = \
4140 Z_SEM_INITIALIZER(name, initial_count, count_limit); \
4141 BUILD_ASSERT(((count_limit) != 0) && \
4142 (((initial_count) < (count_limit)) || ((initial_count) == (count_limit))) && \
4143 ((count_limit) <= K_SEM_MAX_LIMIT));
4144
4146
4147#if defined(CONFIG_SCHED_IPI_SUPPORTED) || defined(__DOXYGEN__)
4148struct k_ipi_work;
4149
4150
4158typedef void (*k_ipi_func_t)(struct k_ipi_work *work);
4159
4170 sys_dnode_t node[CONFIG_MP_MAX_NUM_CPUS]; /* Node in IPI work queue */
4171 k_ipi_func_t func; /* Function to execute on target CPU */
4172 struct k_event event; /* Event to signal when processed */
4173 uint32_t bitmask; /* Bitmask of targeted CPUs */
4177};
4178
4179
4187static inline void k_ipi_work_init(struct k_ipi_work *work)
4188{
4189 k_event_init(&work->event);
4190 for (unsigned int i = 0; i < CONFIG_MP_MAX_NUM_CPUS; i++) {
4191 sys_dnode_init(&work->node[i]);
4192 }
4193 work->bitmask = 0;
4194}
4195
4214int k_ipi_work_add(struct k_ipi_work *work, uint32_t cpu_bitmask,
4215 k_ipi_func_t func);
4216
4239int k_ipi_work_wait(struct k_ipi_work *work, k_timeout_t timeout);
4240
4250
4251#endif /* CONFIG_SCHED_IPI_SUPPORTED */
4252
4256struct k_work_delayable;
4257struct k_work_sync;
4261
4267
4274typedef void (*k_work_handler_t)(struct k_work *work);
4275
4289void k_work_init(struct k_work *work,
4290 k_work_handler_t handler);
4291
4306int k_work_busy_get(const struct k_work *work);
4307
4321static inline bool k_work_is_pending(const struct k_work *work);
4322
4344 struct k_work *work);
4345
4354int k_work_submit(struct k_work *work);
4355
4380bool k_work_flush(struct k_work *work,
4381 struct k_work_sync *sync);
4382
4402int k_work_cancel(struct k_work *work);
4403
4434bool k_work_cancel_sync(struct k_work *work, struct k_work_sync *sync);
4435
4445void k_work_queue_init(struct k_work_q *queue);
4446
4466void k_work_queue_start(struct k_work_q *queue,
4467 k_thread_stack_t *stack, size_t stack_size,
4468 int prio, const struct k_work_queue_config *cfg);
4469
4480void k_work_queue_run(struct k_work_q *queue, const struct k_work_queue_config *cfg);
4481
4491static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue);
4492
4516int k_work_queue_drain(struct k_work_q *queue, bool plug);
4517
4532
4552int k_work_queue_stop(struct k_work_q *queue, k_timeout_t timeout);
4553
4568 k_work_handler_t handler);
4569
4581static inline struct k_work_delayable *
4583
4598
4613static inline bool k_work_delayable_is_pending(
4614 const struct k_work_delayable *dwork);
4615
4630 const struct k_work_delayable *dwork);
4631
4646 const struct k_work_delayable *dwork);
4647
4676 struct k_work_delayable *dwork,
4677 k_timeout_t delay);
4678
4693 k_timeout_t delay);
4694
4731 struct k_work_delayable *dwork,
4732 k_timeout_t delay);
4733
4747 k_timeout_t delay);
4748
4774 struct k_work_sync *sync);
4775
4797
4827 struct k_work_sync *sync);
4828
4830enum {
4834 /* The atomic API is used for all work and queue flags fields to
4835 * enforce sequential consistency in SMP environments.
4836 */
4837
4838 /* Bits that represent the work item states. At least nine of the
4839 * combinations are distinct valid stable states.
4840 */
4841 K_WORK_RUNNING_BIT = 0,
4842 K_WORK_CANCELING_BIT = 1,
4843 K_WORK_QUEUED_BIT = 2,
4844 K_WORK_DELAYED_BIT = 3,
4845 K_WORK_FLUSHING_BIT = 4,
4846
4847 K_WORK_MASK = BIT(K_WORK_DELAYED_BIT) | BIT(K_WORK_QUEUED_BIT)
4848 | BIT(K_WORK_RUNNING_BIT) | BIT(K_WORK_CANCELING_BIT) | BIT(K_WORK_FLUSHING_BIT),
4849
4850 /* Static work flags */
4851 K_WORK_DELAYABLE_BIT = 8,
4852 K_WORK_DELAYABLE = BIT(K_WORK_DELAYABLE_BIT),
4853
4854 /* Dynamic work queue flags */
4855 K_WORK_QUEUE_STARTED_BIT = 0,
4856 K_WORK_QUEUE_STARTED = BIT(K_WORK_QUEUE_STARTED_BIT),
4857 K_WORK_QUEUE_BUSY_BIT = 1,
4858 K_WORK_QUEUE_BUSY = BIT(K_WORK_QUEUE_BUSY_BIT),
4859 K_WORK_QUEUE_DRAIN_BIT = 2,
4860 K_WORK_QUEUE_DRAIN = BIT(K_WORK_QUEUE_DRAIN_BIT),
4861 K_WORK_QUEUE_PLUGGED_BIT = 3,
4862 K_WORK_QUEUE_PLUGGED = BIT(K_WORK_QUEUE_PLUGGED_BIT),
4863 K_WORK_QUEUE_STOP_BIT = 4,
4864 K_WORK_QUEUE_STOP = BIT(K_WORK_QUEUE_STOP_BIT),
4865
4866 /* Static work queue flags */
4867 K_WORK_QUEUE_NO_YIELD_BIT = 8,
4868 K_WORK_QUEUE_NO_YIELD = BIT(K_WORK_QUEUE_NO_YIELD_BIT),
4872 /* Transient work flags */
4873
4879 K_WORK_RUNNING = BIT(K_WORK_RUNNING_BIT),
4880
4885 K_WORK_CANCELING = BIT(K_WORK_CANCELING_BIT),
4886
4892 K_WORK_QUEUED = BIT(K_WORK_QUEUED_BIT),
4893
4899 K_WORK_DELAYED = BIT(K_WORK_DELAYED_BIT),
4900
4905 K_WORK_FLUSHING = BIT(K_WORK_FLUSHING_BIT),
4906};
4907
4913struct k_work {
4917 /* All fields are protected by the work module spinlock. */
4918
4919 /* Node to link into k_work_q pending list. */
4920 sys_snode_t node;
4921
4922 /* The function to be invoked by the work queue thread. */
4923 k_work_handler_t handler;
4924
4925 /* The queue on which the work item was last submitted. */
4926 struct k_work_q *queue;
4927
4928 /* State of the work item.
4929 *
4930 * The item can be DELAYED, QUEUED, and RUNNING simultaneously.
4931 *
4932 * It can be RUNNING and CANCELING simultaneously.
4933 */
4938};
4939
4943#define Z_WORK_INITIALIZER(work_handler) { \
4944 .handler = (work_handler), \
4945}
4949
4959 /* The work item. */
4960 struct k_work work;
4961
4962 /* Timeout used to submit work after a delay. */
4963 struct _timeout timeout;
4964
4965 /* The queue to which the work should be submitted. */
4966 struct k_work_q *queue;
4970};
4971
4975#define Z_WORK_DELAYABLE_INITIALIZER(work_handler) { \
4976 .work = { \
4977 .handler = (work_handler), \
4978 .flags = K_WORK_DELAYABLE, \
4979 }, \
4980}
4984
5001#define K_WORK_DELAYABLE_DEFINE(work, work_handler) \
5002 struct k_work_delayable work \
5003 = Z_WORK_DELAYABLE_INITIALIZER(work_handler)
5004
5008/* Record used to wait for work to flush.
5009 *
5010 * The work item is inserted into the queue that will process (or is
5011 * processing) the item, and will be processed as soon as the item
5012 * completes. When the flusher is processed the semaphore will be
5013 * signaled, releasing the thread waiting for the flush.
5014 */
5015struct z_work_flusher {
5016 struct k_work work;
5017 struct k_sem sem;
5018};
5019
5020/* Record used to wait for work to complete a cancellation.
5021 *
5022 * The work item is inserted into a global queue of pending cancels.
5023 * When a cancelling work item goes idle any matching waiters are
5024 * removed from pending_cancels and are woken.
5025 */
5026struct z_work_canceller {
5027 sys_snode_t node;
5028 struct k_work *work;
5029 struct k_sem sem;
5030};
5034
5054 union {
5055 struct z_work_flusher flusher;
5056 struct z_work_canceller canceller;
5057 };
5061};
5062
5074 const char *name;
5075
5089
5094
5104};
5105
5111struct k_work_q {
5115 /* The thread that animates the work. */
5116 __deprecated struct k_thread thread;
5117
5118 /* The thread ID that animates the work. This may be an external thread
5119 * if k_work_queue_run() is used.
5120 */
5121 k_tid_t thread_id;
5122
5123 /* All the following fields must be accessed only while the
5124 * work module spinlock is held.
5125 */
5126
5127 /* List of k_work items to be worked. */
5128 sys_slist_t pending;
5129
5130 /* Wait queue for idle work thread. */
5131 _wait_q_t notifyq;
5132
5133 /* Wait queue for threads waiting for the queue to drain. */
5134 _wait_q_t drainq;
5135
5136 /* Flags describing queue state. */
5138
5139#if defined(CONFIG_WORKQUEUE_WORK_TIMEOUT)
5140 struct _timeout work_timeout_record;
5141 struct k_work *work;
5142 k_timeout_t work_timeout;
5143 bool finished;
5144#endif /* defined(CONFIG_WORKQUEUE_WORK_TIMEOUT) */
5148};
5149
5150/* Provide the implementation for inline functions declared above */
5151
5152static inline bool k_work_is_pending(const struct k_work *work)
5153{
5154 return k_work_busy_get(work) != 0;
5155}
5156
5157static inline struct k_work_delayable *
5159{
5160 return CONTAINER_OF(work, struct k_work_delayable, work);
5161}
5162
5164 const struct k_work_delayable *dwork)
5165{
5166 return k_work_delayable_busy_get(dwork) != 0;
5167}
5168
5170 const struct k_work_delayable *dwork)
5171{
5172 return z_timeout_expires(&dwork->timeout);
5173}
5174
5176 const struct k_work_delayable *dwork)
5177{
5178 return z_timeout_remaining(&dwork->timeout);
5179}
5180
5181static inline k_tid_t k_work_queue_thread_get(struct k_work_q *queue)
5182{
5183 return queue->thread_id;
5184}
5185
5187
5188struct k_work_user;
5189
5194
5204typedef void (*k_work_user_handler_t)(struct k_work_user *work);
5205
5209struct k_work_user_q {
5210 struct k_queue queue;
5211 struct k_thread thread;
5212};
5213
5214enum {
5215 K_WORK_USER_STATE_PENDING, /* Work item pending state */
5216};
5217
5218struct k_work_user {
5219 void *_reserved; /* Used by k_queue implementation. */
5220 k_work_user_handler_t handler;
5222};
5223
5224#if defined(__cplusplus) && ((__cplusplus - 0) < 202002L)
5225#define Z_WORK_USER_INITIALIZER(work_handler) { NULL, work_handler, 0 }
5226#else
5227#define Z_WORK_USER_INITIALIZER(work_handler) \
5228 { \
5229 ._reserved = NULL, \
5230 .handler = (work_handler), \
5231 .flags = 0 \
5232 }
5233#endif
5237
5249#define K_WORK_USER_DEFINE(work, work_handler) \
5250 struct k_work_user work = Z_WORK_USER_INITIALIZER(work_handler)
5251
5261static inline void k_work_user_init(struct k_work_user *work,
5262 k_work_user_handler_t handler)
5263{
5264 *work = (struct k_work_user)Z_WORK_USER_INITIALIZER(handler);
5265}
5266
5283static inline bool k_work_user_is_pending(struct k_work_user *work)
5284{
5285 return atomic_test_bit(&work->flags, K_WORK_USER_STATE_PENDING);
5286}
5287
5306static inline int k_work_user_submit_to_queue(struct k_work_user_q *work_q,
5307 struct k_work_user *work)
5308{
5309 int ret = -EBUSY;
5310
5311 if (!atomic_test_and_set_bit(&work->flags,
5312 K_WORK_USER_STATE_PENDING)) {
5313 ret = k_queue_alloc_append(&work_q->queue, work);
5314
5315 /* Couldn't insert into the queue. Clear the pending bit
5316 * so the work item can be submitted again
5317 */
5318 if (ret != 0) {
5319 atomic_clear_bit(&work->flags,
5320 K_WORK_USER_STATE_PENDING);
5321 }
5322 }
5323
5324 return ret;
5325}
5326
5346void k_work_user_queue_start(struct k_work_user_q *work_q,
5347 k_thread_stack_t *stack,
5348 size_t stack_size, int prio,
5349 const char *name);
5350
5361static inline k_tid_t k_work_user_queue_thread_get(struct k_work_user_q *work_q)
5362{
5363 return &work_q->thread;
5364}
5365
5367
5371struct k_work_poll {
5372 struct k_work work;
5373 struct k_work_q *workq;
5374 struct z_poller poller;
5375 struct k_poll_event *events;
5376 int num_events;
5377 k_work_handler_t real_handler;
5378 struct _timeout timeout;
5379 int poll_result;
5380};
5384
5389
5401#define K_WORK_DEFINE(work, work_handler) \
5402 struct k_work work = Z_WORK_INITIALIZER(work_handler)
5403
5413void k_work_poll_init(struct k_work_poll *work,
5414 k_work_handler_t handler);
5415
5451 struct k_work_poll *work,
5452 struct k_poll_event *events,
5453 int num_events,
5454 k_timeout_t timeout);
5455
5487int k_work_poll_submit(struct k_work_poll *work,
5488 struct k_poll_event *events,
5489 int num_events,
5490 k_timeout_t timeout);
5491
5506int k_work_poll_cancel(struct k_work_poll *work);
5507
5509
5515
5521struct k_msgq {
5526 _wait_q_t wait_q;
5528 struct k_spinlock lock;
5530 size_t msg_size;
5532 uint32_t max_msgs;
5534 char *buffer_start;
5536 char *buffer_end;
5538 char *read_ptr;
5540 char *write_ptr;
5542 uint32_t used_msgs;
5543
5544 Z_DECL_POLL_EVENT
5545
5547 uint8_t flags;
5548
5549#ifdef CONFIG_OBJ_CORE_MSGQ
5550 struct k_obj_core obj_core;
5551#endif
5555};
5556
5560#define Z_MSGQ_INITIALIZER(obj, q_buffer, q_msg_size, q_max_msgs) \
5561 { \
5562 .wait_q = Z_WAIT_Q_INIT(&obj.wait_q), \
5563 .lock = {}, \
5564 .msg_size = q_msg_size, \
5565 .max_msgs = q_max_msgs, \
5566 .buffer_start = q_buffer, \
5567 .buffer_end = q_buffer + (q_max_msgs * q_msg_size), \
5568 .read_ptr = q_buffer, \
5569 .write_ptr = q_buffer, \
5570 .used_msgs = 0, \
5571 Z_POLL_EVENT_OBJ_INIT(obj) \
5572 .flags = 0, \
5573 }
5574
5575#define K_MSGQ_FLAG_ALLOC BIT(0)
5579
5591
5592
5615#define K_MSGQ_DEFINE(q_name, q_msg_size, q_max_msgs, q_align) \
5616 static char __noinit __aligned(q_align) \
5617 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
5618 STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
5619 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
5620 (q_msg_size), (q_max_msgs))
5621
5635#define K_MSGQ_DEFINE_STATIC(q_name, q_msg_size, q_max_msgs, q_align) \
5636 static char __noinit __aligned(q_align) \
5637 _k_fifo_buf_##q_name[(q_max_msgs) * (q_msg_size)]; \
5638 static STRUCT_SECTION_ITERABLE(k_msgq, q_name) = \
5639 Z_MSGQ_INITIALIZER(q_name, _k_fifo_buf_##q_name, \
5640 (q_msg_size), (q_max_msgs))
5641
5661#define K_MSGQ_DEFINE_TYPE(q_name, q_msg_type, q_max_msgs) \
5662 K_MSGQ_DEFINE(q_name, sizeof(q_msg_type), q_max_msgs, __alignof(q_msg_type))
5663
5675#define K_MSGQ_DEFINE_STATIC_TYPE(q_name, q_msg_type, q_max_msgs) \
5676 K_MSGQ_DEFINE_STATIC(q_name, sizeof(q_msg_type), q_max_msgs, __alignof(q_msg_type))
5677
5692void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
5693 uint32_t max_msgs);
5694
5714__syscall int k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
5715 uint32_t max_msgs);
5716
5730int k_msgq_cleanup(struct k_msgq *msgq);
5731
5752__syscall int k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout);
5753
5778__syscall int k_msgq_put_front(struct k_msgq *msgq, const void *data);
5779
5800__syscall int k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout);
5801
5816__syscall int k_msgq_peek(struct k_msgq *msgq, void *data);
5817
5834__syscall int k_msgq_peek_at(struct k_msgq *msgq, void *data, uint32_t idx);
5835
5845__syscall void k_msgq_purge(struct k_msgq *msgq);
5846
5857__syscall uint32_t k_msgq_num_free_get(struct k_msgq *msgq);
5858
5867__syscall void k_msgq_get_attrs(struct k_msgq *msgq,
5868 struct k_msgq_attrs *attrs);
5869
5870
5871static inline uint32_t z_impl_k_msgq_num_free_get(struct k_msgq *msgq)
5872{
5873 return msgq->max_msgs - msgq->used_msgs;
5874}
5875
5885__syscall uint32_t k_msgq_num_used_get(struct k_msgq *msgq);
5886
5887static inline uint32_t z_impl_k_msgq_num_used_get(struct k_msgq *msgq)
5888{
5889 return msgq->used_msgs;
5890}
5891
5893
5899
5906 size_t size;
5910 void *tx_data;
5919 k_tid_t _syncing_thread;
5920#if (CONFIG_NUM_MBOX_ASYNC_MSGS > 0)
5922 struct k_sem *_async_sem;
5923#endif
5927};
5928
5933struct k_mbox {
5938 _wait_q_t tx_msg_queue;
5940 _wait_q_t rx_msg_queue;
5941 struct k_spinlock lock;
5942
5943#ifdef CONFIG_OBJ_CORE_MAILBOX
5944 struct k_obj_core obj_core;
5945#endif
5949};
5950
5954#define Z_MBOX_INITIALIZER(obj) \
5955 { \
5956 .tx_msg_queue = Z_WAIT_Q_INIT(&obj.tx_msg_queue), \
5957 .rx_msg_queue = Z_WAIT_Q_INIT(&obj.rx_msg_queue), \
5958 }
5962
5972#define K_MBOX_DEFINE(name) \
5973 STRUCT_SECTION_ITERABLE(k_mbox, name) = \
5974 Z_MBOX_INITIALIZER(name) \
5975
5976
5983void k_mbox_init(struct k_mbox *mbox);
5984
6004int k_mbox_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
6005 k_timeout_t timeout);
6006
6020void k_mbox_async_put(struct k_mbox *mbox, struct k_mbox_msg *tx_msg,
6021 struct k_sem *sem);
6022
6040int k_mbox_get(struct k_mbox *mbox, struct k_mbox_msg *rx_msg,
6041 void *buffer, k_timeout_t timeout);
6042
6056void k_mbox_data_get(struct k_mbox_msg *rx_msg, void *buffer);
6057
6059
6065
6075__syscall void k_pipe_init(struct k_pipe *pipe, uint8_t *buffer, size_t buffer_size);
6076
6080enum pipe_flags {
6081 PIPE_FLAG_OPEN = BIT(0),
6082 PIPE_FLAG_RESET = BIT(1),
6083};
6087
6093struct k_pipe {
6097 size_t waiting;
6098 struct ring_buf buf;
6099 struct k_spinlock lock;
6100 _wait_q_t data;
6101 _wait_q_t space;
6102 uint8_t flags;
6103
6104 Z_DECL_POLL_EVENT
6105#ifdef CONFIG_OBJ_CORE_PIPE
6106 struct k_obj_core obj_core;
6107#endif
6111};
6112
6116#define Z_PIPE_INITIALIZER(obj, pipe_buffer, pipe_buffer_size) \
6117{ \
6118 .waiting = 0, \
6119 .buf = RING_BUF_INIT(pipe_buffer, pipe_buffer_size), \
6120 .data = Z_WAIT_Q_INIT(&obj.data), \
6121 .space = Z_WAIT_Q_INIT(&obj.space), \
6122 .flags = PIPE_FLAG_OPEN, \
6123 Z_POLL_EVENT_OBJ_INIT(obj) \
6124}
6128
6142#define K_PIPE_DEFINE(name, pipe_buffer_size, pipe_align) \
6143 static unsigned char __noinit __aligned(pipe_align) \
6144 _k_pipe_buf_##name[pipe_buffer_size]; \
6145 STRUCT_SECTION_ITERABLE(k_pipe, name) = \
6146 Z_PIPE_INITIALIZER(name, _k_pipe_buf_##name, pipe_buffer_size)
6147
6148
6166__syscall int k_pipe_write(struct k_pipe *pipe, const uint8_t *data, size_t len,
6167 k_timeout_t timeout);
6168
6185__syscall int k_pipe_read(struct k_pipe *pipe, uint8_t *data, size_t len,
6186 k_timeout_t timeout);
6187
6197__syscall void k_pipe_reset(struct k_pipe *pipe);
6198
6209__syscall void k_pipe_close(struct k_pipe *pipe);
6211
6215struct k_mem_slab_info {
6216 uint32_t num_blocks;
6217 size_t block_size;
6218 uint32_t num_used;
6219#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
6220 uint32_t max_used;
6221#endif
6222};
6223
6224struct k_mem_slab {
6225 _wait_q_t wait_q;
6226 struct k_spinlock lock;
6227 char *buffer;
6228 char *free_list;
6229 struct k_mem_slab_info info;
6230
6231#ifdef CONFIG_OBJ_CORE_MEM_SLAB
6232 struct k_obj_core obj_core;
6233#endif
6234};
6235
6236#define Z_MEM_SLAB_INITIALIZER(_slab, _slab_buffer, _slab_block_size, \
6237 _slab_num_blocks) \
6238 { \
6239 .wait_q = Z_WAIT_Q_INIT(&(_slab).wait_q), \
6240 .lock = {}, \
6241 .buffer = _slab_buffer, \
6242 .free_list = NULL, \
6243 .info = {_slab_num_blocks, _slab_block_size, 0} \
6244 }
6248
6254
6280#define K_MEM_SLAB_DEFINE_IN_SECT(name, in_section, slab_block_size, slab_num_blocks, slab_align) \
6281 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
6282 "slab_block_size must be a multiple of slab_align"); \
6283 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
6284 "slab_align must be a power of 2"); \
6285 char in_section __aligned(WB_UP( \
6286 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
6287 STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
6288 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
6289
6313#define K_MEM_SLAB_DEFINE(name, slab_block_size, slab_num_blocks, slab_align) \
6314 K_MEM_SLAB_DEFINE_IN_SECT(name, __noinit_named(k_mem_slab_buf_##name), slab_block_size, \
6315 slab_num_blocks, slab_align)
6316
6338#define K_MEM_SLAB_DEFINE_TYPE(name, type, slab_num_blocks) \
6339 K_MEM_SLAB_DEFINE(name, sizeof(type), slab_num_blocks, __alignof(type))
6340
6357#define K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, in_section, slab_block_size, slab_num_blocks, \
6358 slab_align) \
6359 BUILD_ASSERT(((slab_block_size) % (slab_align)) == 0, \
6360 "slab_block_size must be a multiple of slab_align"); \
6361 BUILD_ASSERT((((slab_align) & ((slab_align) - 1)) == 0), \
6362 "slab_align must be a power of 2"); \
6363 static char in_section __aligned(WB_UP( \
6364 slab_align)) _k_mem_slab_buf_##name[(slab_num_blocks) * WB_UP(slab_block_size)]; \
6365 static STRUCT_SECTION_ITERABLE(k_mem_slab, name) = Z_MEM_SLAB_INITIALIZER( \
6366 name, _k_mem_slab_buf_##name, WB_UP(slab_block_size), slab_num_blocks)
6367
6382#define K_MEM_SLAB_DEFINE_STATIC(name, slab_block_size, slab_num_blocks, slab_align) \
6383 K_MEM_SLAB_DEFINE_IN_SECT_STATIC(name, __noinit_named(k_mem_slab_buf_##name), \
6384 slab_block_size, slab_num_blocks, slab_align)
6385
6398#define K_MEM_SLAB_DEFINE_STATIC_TYPE(name, type, slab_num_blocks) \
6399 K_MEM_SLAB_DEFINE_STATIC(name, sizeof(type), slab_num_blocks, __alignof(type))
6400
6422int k_mem_slab_init(struct k_mem_slab *slab, void *buffer,
6423 size_t block_size, uint32_t num_blocks);
6424
6446int k_mem_slab_alloc(struct k_mem_slab *slab, void **mem,
6447 k_timeout_t timeout);
6448
6460void k_mem_slab_free(struct k_mem_slab *slab, void *mem);
6461
6474static inline uint32_t k_mem_slab_num_used_get(struct k_mem_slab *slab)
6475{
6476 return slab->info.num_used;
6477}
6478
6491static inline uint32_t k_mem_slab_max_used_get(struct k_mem_slab *slab)
6492{
6493#ifdef CONFIG_MEM_SLAB_TRACE_MAX_UTILIZATION
6494 return slab->info.max_used;
6495#else
6496 ARG_UNUSED(slab);
6497 return 0;
6498#endif
6499}
6500
6513static inline uint32_t k_mem_slab_num_free_get(struct k_mem_slab *slab)
6514{
6515 return slab->info.num_blocks - slab->info.num_used;
6516}
6517
6531
6532int k_mem_slab_runtime_stats_get(struct k_mem_slab *slab, struct sys_memory_stats *stats);
6533
6547int k_mem_slab_runtime_stats_reset_max(struct k_mem_slab *slab);
6548
6550
6555
6561struct k_heap {
6565 struct sys_heap heap;
6566 _wait_q_t wait_q;
6567 struct k_spinlock lock;
6571};
6572
6586void k_heap_init(struct k_heap *h, void *mem,
6587 size_t bytes) __attribute_nonnull(1);
6588
6610void *k_heap_aligned_alloc(struct k_heap *h, size_t align, size_t bytes,
6611 k_timeout_t timeout) __attribute_nonnull(1);
6612
6634void *k_heap_alloc(struct k_heap *h, size_t bytes,
6635 k_timeout_t timeout) __attribute_nonnull(1);
6636
6659void *k_heap_calloc(struct k_heap *h, size_t num, size_t size, k_timeout_t timeout)
6660 __attribute_nonnull(1);
6661
6685void *k_heap_realloc(struct k_heap *h, void *ptr, size_t bytes, k_timeout_t timeout)
6686 __attribute_nonnull(1);
6687
6698void k_heap_free(struct k_heap *h, void *mem) __attribute_nonnull(1);
6699
6700/*
6701 * Heap sizing constants computed at build time from actual struct layouts
6702 * in lib/heap/heap_constants.c via the gen_offset mechanism.
6703 */
6704#include <zephyr/heap_constants.h>
6705
6706/* chunk0 size in bytes for nb buckets (includes trailer metadata) */
6707#define _Z_HEAP_C0(nb) \
6708 (ROUND_UP(___z_heap_struct_SIZEOF + \
6709 (nb) * ___z_heap_bucket_SIZEOF, ___z_heap_chunk_unit_SIZEOF) + \
6710 ___z_heap_trailer_SIZEOF)
6711
6712/* Allocation chunk size in bytes (header + data rounded up, plus trailer) */
6713#define _Z_HEAP_AC(ab) \
6714 (ROUND_UP(___z_heap_hdr_SIZEOF + (ab), ___z_heap_chunk_unit_SIZEOF) + \
6715 ___z_heap_trailer_SIZEOF)
6716
6717/* Total heap size in chunk units */
6718#define _Z_HEAP_SZ(nb, ab) \
6719 ((_Z_HEAP_C0(nb) + _Z_HEAP_AC(ab)) / ___z_heap_chunk_unit_SIZEOF)
6720
6721/* Bucket count from heap size in chunk units (mirrors bucket_idx() + 1) */
6722#define _Z_HEAP_NB(sz) \
6723 (32 - __builtin_clz((unsigned int)((sz) - \
6724 ___z_heap_min_chunk_SIZEOF + 1)))
6725
6726/* 3-round convergent iteration starting from 1 bucket */
6727#define _Z_HEAP_NB1(ab) _Z_HEAP_NB(_Z_HEAP_SZ(1, ab))
6728#define _Z_HEAP_NB2(ab) _Z_HEAP_NB(_Z_HEAP_SZ(_Z_HEAP_NB1(ab), ab))
6729#define _Z_HEAP_NB3(ab) _Z_HEAP_NB(_Z_HEAP_SZ(_Z_HEAP_NB2(ab), ab))
6730
6744#define Z_HEAP_MIN_SIZE_FOR(alloc_bytes) \
6745 (_Z_HEAP_C0(_Z_HEAP_NB3(alloc_bytes)) + \
6746 _Z_HEAP_AC(alloc_bytes) + ___z_heap_ftr_SIZEOF)
6747
6748#define Z_HEAP_MIN_SIZE Z_HEAP_MIN_SIZE_FOR(1)
6749
6766#define Z_HEAP_DEFINE_IN_SECT(name, bytes, in_section) \
6767 char in_section \
6768 __aligned(8) /* CHUNK_UNIT */ \
6769 kheap_##name[MAX(bytes, Z_HEAP_MIN_SIZE)]; \
6770 STRUCT_SECTION_ITERABLE(k_heap, name) = { \
6771 .heap = { \
6772 .init_mem = kheap_##name, \
6773 .init_bytes = MAX(bytes, Z_HEAP_MIN_SIZE), \
6774 }, \
6775 }
6776
6791#define K_HEAP_DEFINE(name, bytes) \
6792 Z_HEAP_DEFINE_IN_SECT(name, bytes, \
6793 __noinit_named(kheap_buf_##name))
6794
6809#define K_HEAP_DEFINE_NOCACHE(name, bytes) \
6810 Z_HEAP_DEFINE_IN_SECT(name, bytes, __nocache)
6811
6821int k_heap_array_get(struct k_heap **heap);
6822
6826
6833
6852void *k_aligned_alloc(size_t align, size_t size);
6853
6865void *k_malloc(size_t size);
6866
6877void k_free(void *ptr);
6878
6890void *k_calloc(size_t nmemb, size_t size);
6891
6909void *k_realloc(void *ptr, size_t size);
6910
6912
6913/* polling API - PRIVATE */
6914
6915#ifdef CONFIG_POLL
6916#define _INIT_OBJ_POLL_EVENT(obj) do { (obj)->poll_event = NULL; } while (false)
6917#else
6918#define _INIT_OBJ_POLL_EVENT(obj) do { } while (false)
6919#endif
6920
6921/* private - types bit positions */
6922enum _poll_types_bits {
6923 /* can be used to ignore an event */
6924 _POLL_TYPE_IGNORE,
6925
6926 /* to be signaled by k_poll_signal_raise() */
6927 _POLL_TYPE_SIGNAL,
6928
6929 /* semaphore availability */
6930 _POLL_TYPE_SEM_AVAILABLE,
6931
6932 /* queue/FIFO/LIFO data availability */
6933 _POLL_TYPE_DATA_AVAILABLE,
6934
6935 /* msgq data availability */
6936 _POLL_TYPE_MSGQ_DATA_AVAILABLE,
6937
6938 /* pipe data availability */
6939 _POLL_TYPE_PIPE_DATA_AVAILABLE,
6940
6941 _POLL_NUM_TYPES
6942};
6943
6944#define Z_POLL_TYPE_BIT(type) (1U << ((type) - 1U))
6945
6946/* private - states bit positions */
6947enum _poll_states_bits {
6948 /* default state when creating event */
6949 _POLL_STATE_NOT_READY,
6950
6951 /* signaled by k_poll_signal_raise() */
6952 _POLL_STATE_SIGNALED,
6953
6954 /* semaphore is available */
6955 _POLL_STATE_SEM_AVAILABLE,
6956
6957 /* data is available to read on queue/FIFO/LIFO */
6958 _POLL_STATE_DATA_AVAILABLE,
6959
6960 /* queue/FIFO/LIFO wait was cancelled */
6961 _POLL_STATE_CANCELLED,
6962
6963 /* data is available to read on a message queue */
6964 _POLL_STATE_MSGQ_DATA_AVAILABLE,
6965
6966 /* data is available to read from a pipe */
6967 _POLL_STATE_PIPE_DATA_AVAILABLE,
6968
6969 _POLL_NUM_STATES
6970};
6971
6972#define Z_POLL_STATE_BIT(state) (1U << ((state) - 1U))
6973
6974#define _POLL_EVENT_NUM_UNUSED_BITS \
6975 (32 - (0 \
6976 + 8 /* tag */ \
6977 + _POLL_NUM_TYPES \
6978 + _POLL_NUM_STATES \
6979 + 1 /* modes */ \
6980 ))
6981
6982/* end of polling API - PRIVATE */
6983
6984
6992
6993/* Public polling API */
6994
7000
7002#define K_POLL_TYPE_IGNORE 0
7004#define K_POLL_TYPE_SIGNAL Z_POLL_TYPE_BIT(_POLL_TYPE_SIGNAL)
7006#define K_POLL_TYPE_SEM_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_SEM_AVAILABLE)
7008#define K_POLL_TYPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_DATA_AVAILABLE)
7010#define K_POLL_TYPE_FIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
7012#define K_POLL_TYPE_LIFO_DATA_AVAILABLE K_POLL_TYPE_DATA_AVAILABLE
7014#define K_POLL_TYPE_MSGQ_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_MSGQ_DATA_AVAILABLE)
7016#define K_POLL_TYPE_PIPE_DATA_AVAILABLE Z_POLL_TYPE_BIT(_POLL_TYPE_PIPE_DATA_AVAILABLE)
7017
7019
7029
7035
7037#define K_POLL_STATE_NOT_READY 0
7039#define K_POLL_STATE_SIGNALED Z_POLL_STATE_BIT(_POLL_STATE_SIGNALED)
7041#define K_POLL_STATE_SEM_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_SEM_AVAILABLE)
7043#define K_POLL_STATE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_DATA_AVAILABLE)
7045#define K_POLL_STATE_FIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
7047#define K_POLL_STATE_LIFO_DATA_AVAILABLE K_POLL_STATE_DATA_AVAILABLE
7049#define K_POLL_STATE_MSGQ_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_MSGQ_DATA_AVAILABLE)
7051#define K_POLL_STATE_PIPE_DATA_AVAILABLE Z_POLL_STATE_BIT(_POLL_STATE_PIPE_DATA_AVAILABLE)
7053#define K_POLL_STATE_CANCELLED Z_POLL_STATE_BIT(_POLL_STATE_CANCELLED)
7054
7056
7069 sys_dlist_t poll_events;
7073
7078 unsigned int signaled;
7079
7082};
7083
7089#define K_POLL_SIGNAL_INITIALIZER(obj) \
7090 { \
7091 .poll_events = SYS_DLIST_STATIC_INIT(&obj.poll_events), \
7092 .signaled = 0, \
7093 .result = 0, \
7094 }
7095
7104 sys_dnode_t _node;
7105
7107 struct z_poller *poller;
7111
7114
7116 uint32_t type:_POLL_NUM_TYPES;
7117
7119 uint32_t state:_POLL_NUM_STATES;
7120
7123
7125 uint32_t unused:_POLL_EVENT_NUM_UNUSED_BITS;
7126
7128 union {
7129 /* The _typed_* aliases below are used by the K_POLL_EVENT_*INITIALIZER() macros to
7130 * ensure type safety of polled objects.
7131 */
7133 void *obj, *_typed_K_POLL_TYPE_IGNORE;
7135 struct k_poll_signal *signal, *_typed_K_POLL_TYPE_SIGNAL;
7137 struct k_sem *sem, *_typed_K_POLL_TYPE_SEM_AVAILABLE;
7139 struct k_fifo *fifo, *_typed_K_POLL_TYPE_FIFO_DATA_AVAILABLE;
7141 struct k_lifo *lifo, *_typed_K_POLL_TYPE_LIFO_DATA_AVAILABLE;
7143 struct k_queue *queue, *_typed_K_POLL_TYPE_DATA_AVAILABLE;
7145 struct k_msgq *msgq, *_typed_K_POLL_TYPE_MSGQ_DATA_AVAILABLE;
7147 struct k_pipe *pipe, *_typed_K_POLL_TYPE_PIPE_DATA_AVAILABLE;
7148 };
7149};
7150
7159#define K_POLL_EVENT_INITIALIZER(_event_type, _event_mode, _event_obj) \
7160 { \
7161 .poller = NULL, \
7162 .type = _event_type, \
7163 .state = K_POLL_STATE_NOT_READY, \
7164 .mode = _event_mode, \
7165 .unused = 0, \
7166 { \
7167 ._typed_##_event_type = _event_obj, \
7168 }, \
7169 }
7170
7180#define K_POLL_EVENT_STATIC_INITIALIZER(_event_type, _event_mode, _event_obj, \
7181 event_tag) \
7182 { \
7183 .tag = event_tag, \
7184 .type = _event_type, \
7185 .state = K_POLL_STATE_NOT_READY, \
7186 .mode = _event_mode, \
7187 .unused = 0, \
7188 { \
7189 ._typed_##_event_type = _event_obj, \
7190 }, \
7191 }
7192
7207
7208void k_poll_event_init(struct k_poll_event *event, uint32_t type,
7209 int mode, void *obj);
7210
7253
7254__syscall int k_poll(struct k_poll_event *events, int num_events,
7255 k_timeout_t timeout);
7256
7264
7265__syscall void k_poll_signal_init(struct k_poll_signal *sig);
7266
7272__syscall void k_poll_signal_reset(struct k_poll_signal *sig);
7273
7284__syscall void k_poll_signal_check(struct k_poll_signal *sig,
7285 unsigned int *signaled, int *result);
7286
7309
7310__syscall int k_poll_signal_raise(struct k_poll_signal *sig, int result);
7311
7313
7332static inline void k_cpu_idle(void)
7333{
7334 arch_cpu_idle();
7335}
7336
7351static inline void k_cpu_atomic_idle(unsigned int key)
7352{
7354}
7355
7359
7364#ifdef ARCH_EXCEPT
7365/* This architecture has direct support for triggering a CPU exception */
7366#define z_except_reason(reason) ARCH_EXCEPT(reason)
7367#else
7368
7369#if defined(CONFIG_PRINTK) && !defined(CONFIG_ASSERT_NO_FILE_INFO)
7370#define __EXCEPT_LOC() printk("@ %s:%d\n", __FILE__, __LINE__)
7371#else
7372#define __EXCEPT_LOC()
7373#endif /* CONFIG_PRINTK */
7374
7375/* NOTE: This is the implementation for arches that do not implement
7376 * ARCH_EXCEPT() to generate a real CPU exception.
7377 *
7378 * We won't have a real exception frame to determine the PC value when
7379 * the oops occurred, so print file and line number before we jump into
7380 * the fatal error handler.
7381 */
7382#define z_except_reason(reason) do { \
7383 __EXCEPT_LOC(); \
7384 z_fatal_error(reason, NULL); \
7385 } while (false)
7386
7387#endif /* _ARCH__EXCEPT */
7391
7403#define k_oops() z_except_reason(K_ERR_KERNEL_OOPS)
7404
7413#define k_panic() z_except_reason(K_ERR_KERNEL_PANIC)
7414
7418/*
7419 * private APIs that are utilized by one or more public APIs
7420 */
7421
7425void z_timer_expiration_handler(struct _timeout *timeout);
7429
7430#ifdef CONFIG_PRINTK
7438__syscall void k_str_out(char *c, size_t n);
7439#endif
7440
7446
7467__syscall int k_float_disable(struct k_thread *thread);
7468
7507__syscall int k_float_enable(struct k_thread *thread, unsigned int options);
7508
7512
7522
7530
7539
7550
7561
7571
7580
7589
7590#ifdef __cplusplus
7591}
7592#endif
7593
7594#include <zephyr/tracing/tracing.h>
7595#include <zephyr/syscalls/kernel.h>
7596
7597#endif /* !_ASMLANGUAGE */
7598
7599#endif /* ZEPHYR_INCLUDE_KERNEL_H_ */
void(* k_thread_entry_t)(void *p1, void *p2, void *p3)
Thread entry point function type.
Definition arch_interface.h:46
struct z_thread_stack_element k_thread_stack_t
Typedef of struct z_thread_stack_element.
Definition arch_interface.h:44
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 uint32_t arch_k_cycle_get_32(void)
Obtain the current cycle count, in units specified by CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC.
static uint64_t arch_k_cycle_get_64(void)
As for arch_k_cycle_get_32(), but with a 64 bit return value.
static _Bool atomic_test_and_set_bit(atomic_t *target, int bit)
Atomically set a bit and test it.
Definition atomic.h:181
long atomic_t
Atomic integer variable.
Definition atomic_types.h:34
static _Bool atomic_test_bit(const atomic_t *target, int bit)
Atomically get and test a bit.
Definition atomic.h:138
static void atomic_clear_bit(atomic_t *target, int bit)
Atomically clear a bit.
Definition atomic.h:227
atomic_t atomic_val_t
Value type for atomic integer variables.
Definition atomic_types.h:41
static uint32_t k_cycle_get_32(void)
Read the hardware clock.
Definition kernel.h:2301
#define K_NO_WAIT
Generate null timeout delay.
Definition kernel.h:1617
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:2253
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, and update the referenced time.
Definition kernel.h:2282
static uint32_t k_uptime_seconds(void)
Get system uptime in seconds.
Definition kernel.h:2266
static uint64_t k_cycle_get_64(void)
Read the 64-bit hardware clock.
Definition kernel.h:2319
static int64_t k_uptime_get(void)
Get system uptime.
Definition kernel.h:2229
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:7332
static void k_cpu_atomic_idle(unsigned int key)
Make the CPU idle in an atomic fashion.
Definition kernel.h:7351
struct _dnode sys_dnode_t
Doubly-linked list node structure.
Definition dlist.h:59
struct _dnode sys_dlist_t
Doubly-linked list structure.
Definition dlist.h:55
static void sys_dnode_init(sys_dnode_t *node)
initialize node to its state when not in a list
Definition dlist.h:224
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:3082
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:339
struct _sflist sys_sflist_t
Flagged single-linked list structure.
Definition sflist.h:57
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_wake(struct k_futex *futex, bool wake_all)
Wake one/all threads pending on a futex.
int k_futex_wait(struct k_futex *futex, atomic_val_t expected, k_timeout_t timeout)
Pend the current thread 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.
execution_context_types
Types of execution contexts.
Definition kernel.h:138
@ K_ISR
Executing in an interrupt service routine.
Definition kernel.h:139
@ K_COOP_THREAD
Executing in a cooperative thread.
Definition kernel.h:140
@ K_PREEMPT_THREAD
Executing in a preemptible thread.
Definition kernel.h:141
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:6474
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:6491
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:6513
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
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.
void k_poll_signal_reset(struct k_poll_signal *sig)
Reset a poll signal object's state to unsignaled.
k_poll_modes
Modes of operation of a poll event.
Definition kernel.h:7021
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
Polling thread is notified of object availability, but does not take ownership of the object.
Definition kernel.h:7025
@ K_POLL_NUM_MODES
Number of poll modes.
Definition kernel.h:7027
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 the end of a queue, allocating the link.
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, allocating the link.
void k_queue_insert(struct k_queue *queue, void *prev, void *data)
Insert an element into 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:54
struct _snode sys_snode_t
Single-linked list node structure.
Definition slist.h:44
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 IS_ENABLED(config_macro)
Check for macro definition in compiler-visible expressions.
Definition util_macro.h:166
#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:269
#define EBUSY
Mount device busy.
Definition errno.h:55
int k_thread_name_copy(k_tid_t thread, char *buf, size_t size)
Copy the thread name into a supplied buffer.
void k_yield(void)
Yield the current thread.
const char * k_thread_state_str(k_tid_t thread_id, char *buf, size_t buf_size)
Get thread state string.
void k_thread_resume(k_tid_t thread)
Resume a suspended thread.
void * k_thread_custom_data_get(void)
Get current thread's custom data.
void k_thread_abort(k_tid_t thread)
Abort a thread.
int k_thread_name_set(k_tid_t thread, const char *str)
Set current thread name.
void k_thread_priority_set(k_tid_t thread, int prio)
Set a thread's priority.
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:577
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.
static bool k_thread_is_user_thread(const struct k_thread *thread)
Test whether provided thread is user thread.
Definition kernel.h:884
void k_sched_lock(void)
Lock the scheduler.
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:167
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:859
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:1363
#define K_USER
user mode thread
Definition kernel.h:352
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:826
int k_thread_cpu_pin(k_tid_t thread, int cpu)
Pin a thread to a CPU.
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)
Callback type used by thread iteration functions.
Definition kernel.h:180
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:1945
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:1929
void k_timer_init(struct k_timer *timer, k_timer_expiry_t expiry_fn, k_timer_stop_t stop_fn)
Initialize a timer.
int k_timer_cleanup(struct k_timer *timer)
Clean up a dynamically allocated timer before freeing it.
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:2131
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_ceil32(t)
Convert ticks to milliseconds.
Definition time_units.h:1901
#define k_ticks_to_sec_floor32(t)
Convert ticks to seconds.
Definition time_units.h:1741
#define k_ticks_to_ms_floor64(t)
Convert ticks to milliseconds.
Definition time_units.h:1853
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:5181
static bool k_work_is_pending(const struct k_work *work)
Test whether a work item is currently pending.
Definition kernel.h:5152
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:5169
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:5306
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:5283
void(* k_work_handler_t)(struct k_work *work)
The signature for a work item handler function.
Definition kernel.h:4274
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:5163
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:5261
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:5204
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:5361
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:5158
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:5175
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:4885
@ K_WORK_QUEUED
Flag indicating a work item that has been submitted to a queue but has not started running.
Definition kernel.h:4892
@ K_WORK_DELAYED
Flag indicating a delayed work item that is scheduled for submission to a queue.
Definition kernel.h:4899
@ K_WORK_RUNNING
Flag indicating a work item that is running under a work queue thread.
Definition kernel.h:4879
@ K_WORK_FLUSHING
Flag indicating a synced work item that is being flushed.
Definition kernel.h:4905
struct k_thread * k_tid_t
Definition thread.h:414
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.
bool k_thread_runtime_stats_is_enabled(k_tid_t thread)
Check if runtime statistics gathering is enabled for 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.
void(* k_ipi_func_t)(struct k_ipi_work *work)
IPI work item handler function type.
Definition kernel.h:4158
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:4187
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:386
Memory Statistics.
flags
Definition parser.h:86
state
Definition parser_state.h:29
Simple, header-only ring buffer implementation.
Thread sleep APIs.
__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
Kernel condition variable structure.
Definition kernel.h:3897
Event Structure.
Definition kernel.h:2851
Kernel FIFO structure.
Definition kernel.h:3107
futex structure
Definition kernel.h:2780
atomic_t val
Futex value.
Definition kernel.h:2786
Kernel synchronized heap structure.
Definition kernel.h:6561
IPI work item structure.
Definition kernel.h:4166
Kernel LIFO structure.
Definition kernel.h:3430
Mailbox Message Structure.
Definition kernel.h:5904
k_tid_t tx_target_thread
target thread id
Definition kernel.h:5914
void * tx_data
sender's message data buffer
Definition kernel.h:5910
k_tid_t rx_source_thread
source thread id
Definition kernel.h:5912
uint32_t info
application-defined information value
Definition kernel.h:5908
size_t size
size of message (in bytes)
Definition kernel.h:5906
Mailbox Structure.
Definition kernel.h:5933
Memory Domain.
Definition mem_domain.h:87
Memory Partition.
Definition mem_domain.h:62
Message Queue Attributes.
Definition kernel.h:5583
uint32_t used_msgs
Used messages.
Definition kernel.h:5589
size_t msg_size
Message Size.
Definition kernel.h:5585
uint32_t max_msgs
Maximal number of messages.
Definition kernel.h:5587
Message Queue Structure.
Definition kernel.h:5521
Kernel mutex structure.
Definition kernel.h:3764
Object core structure.
Definition obj_core.h:160
Kernel pipe structure.
Definition kernel.h:6093
Poll Event.
Definition kernel.h:7099
struct k_poll_signal * signal
Poll signal being polled.
Definition kernel.h:7135
struct k_pipe * pipe
Pipe being polled.
Definition kernel.h:7147
uint32_t tag
optional user-specified tag, opaque, untouched by the API
Definition kernel.h:7113
struct k_fifo * fifo
FIFO being polled.
Definition kernel.h:7139
struct k_msgq * msgq
Message queue being polled.
Definition kernel.h:7145
struct k_queue * queue
Queue being polled.
Definition kernel.h:7143
uint32_t unused
unused bits in 32-bit word
Definition kernel.h:7125
uint32_t type
bitfield of event types (bitwise-ORed K_POLL_TYPE_xxx values)
Definition kernel.h:7116
struct k_sem * sem
Semaphore being polled.
Definition kernel.h:7137
uint32_t state
bitfield of event states (bitwise-ORed K_POLL_STATE_xxx values)
Definition kernel.h:7119
uint32_t mode
mode of operation, from enum k_poll_modes
Definition kernel.h:7122
void * obj
Generic object pointer.
Definition kernel.h:7133
struct k_lifo * lifo
LIFO being polled.
Definition kernel.h:7141
Poll signal object.
Definition kernel.h:7064
int result
custom result value passed to k_poll_signal_raise() if needed
Definition kernel.h:7081
unsigned int signaled
1 if the event has been signaled, 0 otherwise.
Definition kernel.h:7078
Kernel queue structure.
Definition kernel.h:2340
Semaphore structure.
Definition kernel.h:4002
Kernel Spin Lock.
Definition spinlock.h:45
Thread Structure.
Definition thread.h:258
struct _thread_base base
Definition thread.h:260
struct k_heap * resource_pool
resource pool
Definition thread.h:363
struct __thread_entry entry
thread entry and parameters description
Definition thread.h:302
Kernel timeout type.
Definition clock.h:65
Kernel timer structure.
Definition kernel.h:1840
A structure used to submit work after a delay.
Definition kernel.h:4955
Kernel workqueue structure.
Definition kernel.h:5111
A structure holding optional configuration items for a work queue.
Definition kernel.h:5069
const char * name
The name to be given to the work queue thread.
Definition kernel.h:5074
uint32_t work_timeout_ms
Controls whether work queue monitors work timeouts.
Definition kernel.h:5103
bool essential
Control whether the work queue thread should be marked as essential thread.
Definition kernel.h:5093
bool no_yield
Control whether the work queue thread should yield between items.
Definition kernel.h:5088
A structure holding internal state for a pending synchronous operation on a work item or queue.
Definition kernel.h:5050
A structure used to submit work.
Definition kernel.h:4913
A structure to represent a ring buffer.
Definition ring_buffer.h:68
Definition sys_heap.h:61
Definition mem_stats.h:24
Iterable sections helpers.
static bool k_is_user_context(void)
Indicate whether the CPU is currently in user mode.
Definition syscall.h:120
Macros to abstract toolchain specific capabilities.
Main header file for tracing subsystem API.
Header file for tracing macros.