Batch 28 commit b7fd210 gave ESP NVS iterator versions and RT-Thread workqueue timer state as HARD: all 3 attempts of each ran out of model context, which counts as a failure. Each task comes from the commit Qwen measured, its digest matches, and it is still present at the batch branch head. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1 line
102 KiB
JSON
1 line
102 KiB
JSON
{"LICENSE": " Apache License\n Version 2.0, January 2004\n http://www.apache.org/licenses/\n\n TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\n\n 1. Definitions.\n\n \"License\" shall mean the terms and conditions for use, reproduction,\n and distribution as defined by Sections 1 through 9 of this document.\n\n \"Licensor\" shall mean the copyright owner or entity authorized by\n the copyright owner that is granting the License.\n\n \"Legal Entity\" shall mean the union of the acting entity and all\n other entities that control, are controlled by, or are under common\n control with that entity. For the purposes of this definition,\n \"control\" means (i) the power, direct or indirect, to cause the\n direction or management of such entity, whether by contract or\n otherwise, or (ii) ownership of fifty percent (50%) or more of the\n outstanding shares, or (iii) beneficial ownership of such entity.\n\n \"You\" (or \"Your\") shall mean an individual or Legal Entity\n exercising permissions granted by this License.\n\n \"Source\" form shall mean the preferred form for making modifications,\n including but not limited to software source code, documentation\n source, and configuration files.\n\n \"Object\" form shall mean any form resulting from mechanical\n transformation or translation of a Source form, including but\n not limited to compiled object code, generated documentation,\n and conversions to other media types.\n\n \"Work\" shall mean the work of authorship, whether in Source or\n Object form, made available under the License, as indicated by a\n copyright notice that is included in or attached to the work\n (an example is provided in the Appendix below).\n\n \"Derivative Works\" shall mean any work, whether in Source or Object\n form, that is based on (or derived from) the Work and for which the\n editorial revisions, annotations, elaborations, or other modifications\n represent, as a whole, an original work of authorship. For the purposes\n of this License, Derivative Works shall not include works that remain\n separable from, or merely link (or bind by name) to the interfaces of,\n the Work and Derivative Works thereof.\n\n \"Contribution\" shall mean any work of authorship, including\n the original version of the Work and any modifications or additions\n to that Work or Derivative Works thereof, that is intentionally\n submitted to Licensor for inclusion in the Work by the copyright owner\n or by an individual or Legal Entity authorized to submit on behalf of\n the copyright owner. For the purposes of this definition, \"submitted\"\n means any form of electronic, verbal, or written communication sent\n to the Licensor or its representatives, including but not limited to\n communication on electronic mailing lists, source code control systems,\n and issue tracking systems that are managed by, or on behalf of, the\n Licensor for the purpose of discussing and improving the Work, but\n excluding communication that is conspicuously marked or otherwise\n designated in writing by the copyright owner as \"Not a Contribution.\"\n\n \"Contributor\" shall mean Licensor and any individual or Legal Entity\n on behalf of whom a Contribution has been received by Licensor and\n subsequently incorporated within the Work.\n\n 2. Grant of Copyright License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n copyright license to reproduce, prepare Derivative Works of,\n publicly display, publicly perform, sublicense, and distribute the\n Work and such Derivative Works in Source or Object form.\n\n 3. Grant of Patent License. Subject to the terms and conditions of\n this License, each Contributor hereby grants to You a perpetual,\n worldwide, non-exclusive, no-charge, royalty-free, irrevocable\n (except as stated in this section) patent license to make, have made,\n use, offer to sell, sell, import, and otherwise transfer the Work,\n where such license applies only to those patent claims licensable\n by such Contributor that are necessarily infringed by their\n Contribution(s) alone or by combination of their Contribution(s)\n with the Work to which such Contribution(s) was submitted. If You\n institute patent litigation against any entity (including a\n cross-claim or counterclaim in a lawsuit) alleging that the Work\n or a Contribution incorporated within the Work constitutes direct\n or contributory patent infringement, then any patent licenses\n granted to You under this License for that Work shall terminate\n as of the date such litigation is filed.\n\n 4. Redistribution. You may reproduce and distribute copies of the\n Work or Derivative Works thereof in any medium, with or without\n modifications, and in Source or Object form, provided that You\n meet the following conditions:\n\n (a) You must give any other recipients of the Work or\n Derivative Works a copy of this License; and\n\n (b) You must cause any modified files to carry prominent notices\n stating that You changed the files; and\n\n (c) You must retain, in the Source form of any Derivative Works\n that You distribute, all copyright, patent, trademark, and\n attribution notices from the Source form of the Work,\n excluding those notices that do not pertain to any part of\n the Derivative Works; and\n\n (d) If the Work includes a \"NOTICE\" text file as part of its\n distribution, then any Derivative Works that You distribute must\n include a readable copy of the attribution notices contained\n within such NOTICE file, excluding those notices that do not\n pertain to any part of the Derivative Works, in at least one\n of the following places: within a NOTICE text file distributed\n as part of the Derivative Works; within the Source form or\n documentation, if provided along with the Derivative Works; or,\n within a display generated by the Derivative Works, if and\n wherever such third-party notices normally appear. The contents\n of the NOTICE file are for informational purposes only and\n do not modify the License. You may add Your own attribution\n notices within Derivative Works that You distribute, alongside\n or as an addendum to the NOTICE text from the Work, provided\n that such additional attribution notices cannot be construed\n as modifying the License.\n\n You may add Your own copyright statement to Your modifications and\n may provide additional or different license terms and conditions\n for use, reproduction, or distribution of Your modifications, or\n for any such Derivative Works as a whole, provided Your use,\n reproduction, and distribution of the Work otherwise complies with\n the conditions stated in this License.\n\n 5. Submission of Contributions. Unless You explicitly state otherwise,\n any Contribution intentionally submitted for inclusion in the Work\n by You to the Licensor shall be under the terms and conditions of\n this License, without any additional terms or conditions.\n Notwithstanding the above, nothing herein shall supersede or modify\n the terms of any separate license agreement you may have executed\n with Licensor regarding such Contributions.\n\n 6. Trademarks. This License does not grant permission to use the trade\n names, trademarks, service marks, or product names of the Licensor,\n except as required for reasonable and customary use in describing the\n origin of the Work and reproducing the content of the NOTICE file.\n\n 7. Disclaimer of Warranty. Unless required by applicable law or\n agreed to in writing, Licensor provides the Work (and each\n Contributor provides its Contributions) on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n implied, including, without limitation, any warranties or conditions\n of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\n PARTICULAR PURPOSE. You are solely responsible for determining the\n appropriateness of using or redistributing the Work and assume any\n risks associated with Your exercise of permissions under this License.\n\n 8. Limitation of Liability. In no event and under no legal theory,\n whether in tort (including negligence), contract, or otherwise,\n unless required by applicable law (such as deliberate and grossly\n negligent acts) or agreed to in writing, shall any Contributor be\n liable to You for damages, including any direct, indirect, special,\n incidental, or consequential damages of any character arising as a\n result of this License or out of the use or inability to use the\n Work (including but not limited to damages for loss of goodwill,\n work stoppage, computer failure or malfunction, or any and all\n other commercial damages or losses), even if such Contributor\n has been advised of the possibility of such damages.\n\n 9. Accepting Warranty or Additional Liability. While redistributing\n the Work or Derivative Works thereof, You may choose to offer,\n and charge a fee for, acceptance of support, warranty, indemnity,\n or other liability obligations and/or rights consistent with this\n License. However, in accepting such obligations, You may act only\n on Your own behalf and on Your sole responsibility, not on behalf\n of any other Contributor, and only if You agree to indemnify,\n defend, and hold each Contributor harmless for any liability\n incurred by, or claims asserted against, such Contributor by reason\n of your accepting any such warranty or additional liability.\n\n END OF TERMS AND CONDITIONS\n\n APPENDIX: How to apply the Apache License to your work.\n\n To apply the Apache License to your work, attach the following\n boilerplate notice, with the fields enclosed by brackets \"[]\"\n replaced with your own identifying information. (Don't include\n the brackets!) The text should be enclosed in the appropriate\n comment syntax for the file format. We also recommend that a\n file or class name and description of purpose be included on the\n same \"printed page\" as the copyright notice for easier\n identification within third-party archives.\n\n Copyright [yyyy] [name of copyright owner]\n\n Licensed under the Apache License, Version 2.0 (the \"License\");\n you may not use this file except in compliance with the License.\n You may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\n Unless required by applicable law or agreed to in writing, software\n distributed under the License is distributed on an \"AS IS\" BASIS,\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n See the License for the specific language governing permissions and\n limitations under the License.\n", "components/drivers/include/ipc/workqueue.h": "/*\n * Copyright (c) 2006-2023, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2021-08-01 Meco Man remove rt_delayed_work_init() and rt_delayed_work structure\n * 2021-08-14 Jackistang add comments for rt_work_init()\n */\n#ifndef WORKQUEUE_H__\n#define WORKQUEUE_H__\n\n#include <rtdef.h>\n#include <rtconfig.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\nenum\n{\n RT_WORK_STATE_PENDING = 0x0001, /* Work item pending state */\n RT_WORK_STATE_SUBMITTING = 0x0002, /* Work item submitting state */\n};\n\n/**\n * work type definitions\n */\nenum\n{\n RT_WORK_TYPE_DELAYED = 0x0001,\n};\n\n/* workqueue implementation */\nstruct rt_workqueue\n{\n rt_list_t work_list;\n rt_list_t delayed_list;\n struct rt_work *work_current; /* current work */\n\n struct rt_semaphore sem;\n rt_thread_t work_thread;\n struct rt_spinlock spinlock;\n};\n\nstruct rt_work\n{\n rt_list_t list;\n\n void (*work_func)(struct rt_work *work, void *work_data);\n void *work_data;\n rt_uint16_t flags;\n rt_uint16_t type;\n struct rt_timer timer;\n struct rt_workqueue *workqueue;\n};\n\n#ifdef RT_USING_HEAP\n/**\n * WorkQueue for DeviceDriver\n */\nvoid rt_work_init(struct rt_work *work, void (*work_func)(struct rt_work *work, void *work_data), void *work_data);\nstruct rt_workqueue *rt_workqueue_create(const char *name, rt_uint16_t stack_size, rt_uint8_t priority);\nrt_err_t rt_workqueue_destroy(struct rt_workqueue *queue);\nrt_err_t rt_workqueue_dowork(struct rt_workqueue *queue, struct rt_work *work);\nrt_err_t rt_workqueue_submit_work(struct rt_workqueue *queue, struct rt_work *work, rt_tick_t ticks);\nrt_err_t rt_workqueue_cancel_work(struct rt_workqueue *queue, struct rt_work *work);\nrt_err_t rt_workqueue_cancel_work_sync(struct rt_workqueue *queue, struct rt_work *work);\nrt_err_t rt_workqueue_cancel_all_work(struct rt_workqueue *queue);\nrt_err_t rt_workqueue_urgent_work(struct rt_workqueue *queue, struct rt_work *work);\n\n#ifdef RT_USING_SYSTEM_WORKQUEUE\nrt_err_t rt_work_submit(struct rt_work *work, rt_tick_t ticks);\nrt_err_t rt_work_urgent(struct rt_work *work);\nrt_err_t rt_work_cancel(struct rt_work *work);\n#endif /* RT_USING_SYSTEM_WORKQUEUE */\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* RT_USING_HEAP */\n\n#endif\n", "port/rtdevice.h": "/* SPDX-License-Identifier: Apache-2.0 */\n#include <rtthread.h>\n#include <ipc/workqueue.h>\n", "port/rtconfig.h": "/* SPDX-License-Identifier: Apache-2.0 */\n#ifndef HOST_RTCONFIG_H\n#define HOST_RTCONFIG_H\n#define ARCH_CPU_64BIT\n#define RT_USING_LIBC\n#define RT_USING_NEWLIBC\n#define RT_USING_HEAP\n#define RT_USING_SEMAPHORE\n#define RT_USING_TIMER_SOFT\n#define RT_USING_DEBUG\n#define RT_USING_HOOK\n#define RT_HOOK_USING_FUNC_PTR\n#define RT_NAME_MAX 16\n#define RT_ALIGN_SIZE 8\n#define RT_THREAD_PRIORITY_MAX 32\n#define RT_TIMER_SKIP_LIST_LEVEL 1\n#define RT_TIMER_SKIP_LIST_MASK 3\n#endif\n", "port/port.h": "/* SPDX-License-Identifier: Apache-2.0 */\n#ifndef HOST_PORT_H\n#define HOST_PORT_H\n#include <rtthread.h>\nvoid os_init(void);\nvoid os_tick(rt_tick_t tick);\nint os_step(const char *name);\nvoid os_drain(void);\n#endif\n", "port/port.c": "/* SPDX-License-Identifier: Apache-2.0\n * Deterministic single-CPU platform: contexts, interrupt masking, IPC and objects.\n */\n#define _XOPEN_SOURCE 700\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <ucontext.h>\n#include <rtthread.h>\n#include <rthw.h>\n#include \"port.h\"\n#define THREADS 16\nstruct host_thread {\n rt_thread_t thread;\n ucontext_t ctx;\n char stack[131072];\n void (*entry)(void *);\n void *arg;\n int ready, dead, masked, critical;\n rt_sem_t wait;\n rt_tick_t wake;\n int finite, result;\n};\nstatic struct host_thread threads[THREADS];\nstatic int count, current=-1, main_mask, main_critical;\nstatic ucontext_t supervisor;\nstatic rt_tick_t ticks;\nvoid (*rt_object_take_hook)(struct rt_object *);\nvoid (*rt_object_put_hook)(struct rt_object *);\nstatic struct host_thread *find(rt_thread_t t) {\n int i; for(i=0;i<count;i++) if(threads[i].thread==t) return &threads[i];\n fputs(\"unknown thread\\n\",stderr);exit(70);\n}\nstatic void yield(void) { if(current>=0) swapcontext(&threads[current].ctx,&supervisor); }\nstatic void start(int i) { threads[i].entry(threads[i].arg);threads[i].dead=1;threads[i].ready=0;yield();abort(); }\nvoid os_init(void) { count=0;current=-1;main_mask=main_critical=0;ticks=0; }\nint os_step(const char *name) {\n int i;\n for(i=0;i<count;i++) if(threads[i].ready && !threads[i].dead && (!name || !strcmp(threads[i].thread->parent.name,name))) {\n current=i;swapcontext(&supervisor,&threads[i].ctx);current=-1;return 1;\n }\n return 0;\n}\nvoid os_drain(void) { int budget=10000;while(os_step(NULL)) if(--budget==0) {fputs(\"scheduler budget\\n\",stderr);exit(71);} }\nvoid os_tick(rt_tick_t tick) {\n int i;ticks=tick;\n for(i=0;i<count;i++) if(threads[i].wait && threads[i].finite && (ticks-threads[i].wake)<RT_TICK_MAX/2) {\n threads[i].wait=NULL;threads[i].ready=1;threads[i].result=-RT_ETIMEOUT;\n }\n}\nrt_tick_t rt_tick_get(void) { return ticks; }\nvoid rt_tick_set(rt_tick_t t) {os_tick(t);}\nrt_base_t rt_hw_interrupt_disable(void) {int *p=current<0?&main_mask:&threads[current].masked;int old=*p;*p=1;return old;}\nvoid rt_hw_interrupt_enable(rt_base_t level) {\n int *p=current<0?&main_mask:&threads[current].masked;*p=(int)level;\n if(current>=0 && !*p && !threads[current].critical) yield();\n}\nrt_base_t rt_enter_critical(void) {if(current<0)return main_critical++;return threads[current].critical++;}\nvoid rt_exit_critical(void) {if(current<0)main_critical--;else threads[current].critical--;}\nrt_uint8_t rt_interrupt_get_nest(void) {return 1;}\nrt_err_t rt_sched_lock(rt_sched_lock_level_t *p) {*p=rt_hw_interrupt_disable();return RT_EOK;}\nrt_err_t rt_sched_unlock(rt_sched_lock_level_t v) {rt_hw_interrupt_enable(v);return RT_EOK;}\nrt_err_t rt_sched_thread_timer_start(rt_thread_t t) {(void)t;return RT_EOK;}\nvoid rt_schedule(void) {yield();}\nrt_thread_t rt_thread_self(void) {return current<0?NULL:threads[current].thread;}\nrt_err_t rt_thread_init(rt_thread_t t,const char *name,void (*entry)(void *),void *arg,void *stack,rt_uint32_t size,rt_uint8_t priority,rt_uint32_t tick) {\n struct host_thread *h;\n (void)stack;(void)size;(void)priority;(void)tick;\n if(count==THREADS)return -RT_ERROR;\n h=&threads[count];memset(h,0,sizeof(*h));h->thread=t;h->entry=entry;h->arg=arg;\n rt_object_init(&t->parent,RT_Object_Class_Thread,name);\n getcontext(&h->ctx);h->ctx.uc_stack.ss_sp=h->stack;h->ctx.uc_stack.ss_size=sizeof(h->stack);h->ctx.uc_link=&supervisor;\n makecontext(&h->ctx,(void (*)(void))start,1,count++);return RT_EOK;\n}\nrt_thread_t rt_thread_create(const char *n,void (*e)(void *),void *a,rt_uint32_t s,rt_uint8_t p,rt_uint32_t t) {\n rt_thread_t thread=calloc(1,sizeof(*thread));if(thread)rt_thread_init(thread,n,e,a,NULL,s,p,t);return thread;\n}\nrt_err_t rt_thread_startup(rt_thread_t t) {find(t)->ready=1;return RT_EOK;}\nrt_err_t rt_thread_resume(rt_thread_t t) {find(t)->ready=1;return RT_EOK;}\nrt_err_t rt_thread_suspend_with_flag(rt_thread_t t,int flag) {(void)flag;find(t)->ready=0;return RT_EOK;}\nrt_err_t rt_thread_delete(rt_thread_t t) {find(t)->dead=1;find(t)->ready=0;return RT_EOK;}\nrt_err_t rt_sem_init(rt_sem_t s,const char *n,rt_uint32_t value,rt_uint8_t flag) {rt_object_init(&s->parent.parent,RT_Object_Class_Semaphore,n);s->value=value;s->max_value=RT_SEM_VALUE_MAX;(void)flag;return RT_EOK;}\nrt_err_t rt_sem_detach(rt_sem_t s) {(void)s;return RT_EOK;}\nrt_err_t rt_sem_trytake(rt_sem_t s) {if(!s->value)return -RT_ETIMEOUT;s->value--;return RT_EOK;}\nrt_err_t rt_sem_take(rt_sem_t s,rt_int32_t timeout) {\n struct host_thread *h;\n if(s->value){s->value--;return RT_EOK;}if(!timeout)return -RT_ETIMEOUT;\n if(current<0){fputs(\"main blocked\\n\",stderr);exit(72);}\n h=&threads[current];h->wait=s;h->ready=0;h->finite=timeout>0;h->wake=ticks+(rt_tick_t)timeout;yield();return h->result;\n}\nrt_err_t rt_sem_release(rt_sem_t s) {\n int i;for(i=0;i<count;i++)if(threads[i].wait==s){threads[i].wait=NULL;threads[i].ready=1;threads[i].result=RT_EOK;return RT_EOK;}\n if(s->value<s->max_value)s->value++;return RT_EOK;\n}\nrt_err_t rt_sem_control(rt_sem_t s,int cmd,void *arg) {if(cmd==RT_IPC_CMD_SET_VLIMIT)s->max_value=(rt_ubase_t)arg;return RT_EOK;}\nvoid rt_object_init(rt_object_t o,enum rt_object_class_type type,const char *name) {memset(o,0,sizeof(*o));o->type=type|RT_Object_Class_Static;strncpy(o->name,name,RT_NAME_MAX-1);rt_list_init(&o->list);}\nvoid rt_object_detach(rt_object_t o) {o->type=RT_Object_Class_Null;}\nrt_uint8_t rt_object_get_type(rt_object_t o) {return o->type&~RT_Object_Class_Static;}\nrt_bool_t rt_object_is_systemobject(rt_object_t o) {return !!(o->type&RT_Object_Class_Static);}\nrt_object_t rt_object_allocate(enum rt_object_class_type type,const char *name) {rt_object_t o=calloc(1,sizeof(struct rt_timer));if(o){rt_object_init(o,type,name);o->type=type;}return o;}\nvoid rt_object_delete(rt_object_t o) {free(o);}\nvoid *rt_malloc(rt_size_t size) {return calloc(1,size);}\nvoid rt_free(void *p) {free(p);}\nvoid rt_assert_handler(const char *ex,const char *func,rt_size_t line) {fprintf(stderr,\"assert %s %s:%lu\\n\",ex,func,(unsigned long)line);exit(73);}\n", "include/rtsched.h": "/*\n * Copyright (c) 2023-2024, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2024-01-19 Shell Seperate schduling statements from rt_thread_t\n * to rt_sched_thread_ctx. Add definitions of scheduler.\n */\n#ifndef __RT_SCHED_H__\n#define __RT_SCHED_H__\n\n#include \"rttypes.h\"\n#include \"rtcompiler.h\"\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\nstruct rt_thread;\n\ntypedef rt_uint8_t rt_sched_thread_status_t;\n\n#ifdef RT_USING_SCHED_THREAD_CTX\n\n/**\n * Scheduler private status binding on thread. Caller should never accessing\n * these members.\n */\nstruct rt_sched_thread_priv\n{\n rt_tick_t init_tick; /**< thread's initialized tick */\n rt_tick_t remaining_tick; /**< remaining tick */\n\n /* priority */\n rt_uint8_t current_priority; /**< current priority */\n rt_uint8_t init_priority; /**< initialized priority */\n#if RT_THREAD_PRIORITY_MAX > 32\n rt_uint8_t number; /**< priority low number */\n rt_uint8_t high_mask; /**< priority high mask */\n#endif /* RT_THREAD_PRIORITY_MAX > 32 */\n rt_uint32_t number_mask; /**< priority number mask */\n\n};\n\n/**\n * Scheduler public status binding on thread. Caller must hold the scheduler\n * lock before access any one of its member.\n */\nstruct rt_sched_thread_ctx\n{\n rt_list_t thread_list_node; /**< node in thread list */\n\n rt_uint8_t stat; /**< thread status */\n rt_uint8_t sched_flag_locked:1; /**< calling thread have the scheduler locked */\n rt_uint8_t sched_flag_ttmr_set:1; /**< thread timer is start */\n\n#ifdef RT_USING_SMP\n rt_uint8_t bind_cpu; /**< thread is bind to cpu */\n rt_uint8_t oncpu; /**< process on cpu */\n\n rt_base_t critical_lock_nest; /**< critical lock count */\n#endif\n\n struct rt_sched_thread_priv sched_thread_priv; /**< private context of scheduler */\n};\n\n#define RT_SCHED_THREAD_CTX struct rt_sched_thread_ctx sched_thread_ctx;\n\n#define RT_SCHED_PRIV(thread) ((thread)->sched_thread_ctx.sched_thread_priv)\n#define RT_SCHED_CTX(thread) ((thread)->sched_thread_ctx)\n\n/**\n * Convert a list node in container RT_SCHED_CTX(thread)->thread_list_node\n * to a thread pointer.\n */\n#define RT_THREAD_LIST_NODE_ENTRY(node) \\\n rt_container_of( \\\n rt_list_entry((node), struct rt_sched_thread_ctx, thread_list_node), \\\n struct rt_thread, sched_thread_ctx)\n#define RT_THREAD_LIST_NODE(thread) (RT_SCHED_CTX(thread).thread_list_node)\n\n#else /* !defined(RT_USING_SCHED_THREAD_CTX) */\n\n#if RT_THREAD_PRIORITY_MAX > 32\n#define _RT_SCHED_THREAD_CTX_PRIO_EXT \\\n rt_uint8_t number; /**< priority low number */ \\\n rt_uint8_t high_mask; /**< priority high mask */\n\n#else /* ! RT_THREAD_PRIORITY_MAX > 32 */\n\n#define _RT_SCHED_THREAD_CTX_PRIO_EXT\n#endif /* RT_THREAD_PRIORITY_MAX > 32 */\n\n#define RT_SCHED_THREAD_CTX \\\n rt_list_t tlist; /**< node in thread list */ \\\n rt_uint8_t stat; /**< thread status */ \\\n rt_uint8_t sched_flag_locked:1; \\\n /**< calling thread have the scheduler locked */ \\\n rt_uint8_t sched_flag_ttmr_set:1; /**< thread timer is start */ \\\n rt_tick_t init_tick; /**< thread's initialized tick */ \\\n rt_tick_t remaining_tick; /**< remaining tick */ \\\n rt_uint8_t current_priority; /**< current priority */ \\\n rt_uint8_t init_priority; /**< initialized priority */ \\\n _RT_SCHED_THREAD_CTX_PRIO_EXT \\\n rt_uint32_t number_mask; /**< priority number mask */\n\n#define RT_SCHED_PRIV(thread) (*thread)\n#define RT_SCHED_CTX(thread) (*thread)\n\n/**\n * Convert a list node in container RT_SCHED_CTX(thread)->thread_list_node\n * to a thread pointer.\n */\n#define RT_THREAD_LIST_NODE_ENTRY(node) rt_list_entry((node), struct rt_thread, tlist)\n#define RT_THREAD_LIST_NODE(thread) (RT_SCHED_CTX(thread).tlist)\n\n#endif /* RT_USING_SCHED_THREAD_CTX */\n\n/**\n * System Scheduler Locking\n */\n\ntypedef rt_ubase_t rt_sched_lock_level_t;\n\nrt_err_t rt_sched_lock(rt_sched_lock_level_t *plvl);\nrt_err_t rt_sched_unlock(rt_sched_lock_level_t level);\nrt_err_t rt_sched_unlock_n_resched(rt_sched_lock_level_t level);\n\nrt_bool_t rt_sched_is_locked(void);\n\n#ifdef RT_USING_SMP\n#define RT_SCHED_DEBUG_IS_LOCKED do { RT_ASSERT(rt_sched_is_locked()); } while (0)\n#define RT_SCHED_DEBUG_IS_UNLOCKED do { RT_ASSERT(!rt_sched_is_locked()); } while (0)\n\n#else /* !RT_USING_SMP */\n\n#define RT_SCHED_DEBUG_IS_LOCKED\n#define RT_SCHED_DEBUG_IS_UNLOCKED\n#endif /* RT_USING_SMP */\n\n/**\n * NOTE: user should NEVER use these APIs directly. See rt_thread_.* or IPC\n * methods instead.\n */\n#if defined(__RT_KERNEL_SOURCE__) || defined(__RT_IPC_SOURCE__)\n\n/* thread initialization and startup routine */\nvoid rt_sched_thread_init_ctx(struct rt_thread *thread, rt_uint32_t tick, rt_uint8_t priority);\nvoid rt_sched_thread_init_priv(struct rt_thread *thread, rt_uint32_t tick, rt_uint8_t priority);\nvoid rt_sched_thread_startup(struct rt_thread *thread);\n\n/* scheduler related routine */\nvoid rt_sched_post_ctx_switch(struct rt_thread *thread);\nrt_err_t rt_sched_tick_increase(void);\n\n/* thread status operation */\nrt_uint8_t rt_sched_thread_get_stat(struct rt_thread *thread);\nrt_uint8_t rt_sched_thread_get_curr_prio(struct rt_thread *thread);\nrt_uint8_t rt_sched_thread_get_init_prio(struct rt_thread *thread);\nrt_err_t rt_sched_thread_yield(struct rt_thread *thread);\nrt_err_t rt_sched_thread_close(struct rt_thread *thread);\nrt_err_t rt_sched_thread_ready(struct rt_thread *thread);\nrt_err_t rt_sched_thread_suspend(struct rt_thread *thread, rt_sched_lock_level_t level);\nrt_err_t rt_sched_thread_change_priority(struct rt_thread *thread, rt_uint8_t priority);\nrt_err_t rt_sched_thread_bind_cpu(struct rt_thread *thread, int cpu);\nrt_uint8_t rt_sched_thread_is_suspended(struct rt_thread *thread);\nrt_err_t rt_sched_thread_timer_stop(struct rt_thread *thread);\nrt_err_t rt_sched_thread_timer_start(struct rt_thread *thread);\nvoid rt_sched_insert_thread(struct rt_thread *thread);\nvoid rt_sched_remove_thread(struct rt_thread *thread);\n\n#endif /* defined(__RT_KERNEL_SOURCE__) || defined(__RT_IPC_SOURCE__) */\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __RT_SCHED_H__ */\n", "include/rtklibc.h": "/*\n * Copyright (c) 2006-2024, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2024-03-10 Meco Man the first version\n */\n\n#ifndef __RT_KLIBC_H__\n#define __RT_KLIBC_H__\n\n#include <rtconfig.h>\n#include <rtdef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* kstdio */\n\nint rt_vsprintf(char *dest, const char *format, va_list arg_ptr);\nint rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args);\nint rt_sprintf(char *buf, const char *format, ...);\nint rt_snprintf(char *buf, rt_size_t size, const char *format, ...);\n\n/* kstring */\n\n#ifndef RT_KSERVICE_USING_STDLIB_MEMORY\nvoid *rt_memset(void *src, int c, rt_ubase_t n);\nvoid *rt_memcpy(void *dest, const void *src, rt_ubase_t n);\nvoid *rt_memmove(void *dest, const void *src, rt_size_t n);\nrt_int32_t rt_memcmp(const void *cs, const void *ct, rt_size_t count);\n#endif /* RT_KSERVICE_USING_STDLIB_MEMORY */\nchar *rt_strdup(const char *s);\nrt_size_t rt_strnlen(const char *s, rt_ubase_t maxlen);\n#ifndef RT_KSERVICE_USING_STDLIB\nchar *rt_strstr(const char *str1, const char *str2);\nrt_int32_t rt_strcasecmp(const char *a, const char *b);\nchar *rt_strcpy(char *dst, const char *src);\nchar *rt_strncpy(char *dest, const char *src, rt_size_t n);\nrt_int32_t rt_strncmp(const char *cs, const char *ct, rt_size_t count);\nrt_int32_t rt_strcmp(const char *cs, const char *ct);\nrt_size_t rt_strlen(const char *src);\n#else\n#include <string.h>\n#ifdef RT_KSERVICE_USING_STDLIB_MEMORY\n#define rt_memset(s, c, count) memset(s, c, count)\n#define rt_memcpy(dst, src, count) memcpy(dst, src, count)\n#define rt_memmove(dest, src, n) memmove(dest, src, n)\n#define rt_memcmp(cs, ct, count) memcmp(cs, ct, count)\n#endif /* RT_KSERVICE_USING_STDLIB_MEMORY */\n#define rt_strstr(str1, str2) strstr(str1, str2)\n#define rt_strcasecmp(a, b) strcasecmp(a, b)\n#define rt_strcpy(dest, src) strcpy(dest, src)\n#define rt_strncpy(dest, src, n) strncpy(dest, src, n)\n#define rt_strncmp(cs, ct, count) strncmp(cs, ct, count)\n#define rt_strcmp(cs, ct) strcmp(cs, ct)\n#define rt_strlen(src) strlen(src)\n#endif /*RT_KSERVICE_USING_STDLIB*/\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __RT_KLIBC_H__ */\n", "include/rtservice.h": "/*\n * Copyright (c) 2006-2021, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2006-03-16 Bernard the first version\n * 2006-09-07 Bernard move the kservice APIs to rtthread.h\n * 2007-06-27 Bernard fix the rt_list_remove bug\n * 2012-03-22 Bernard rename kservice.h to rtservice.h\n * 2017-11-15 JasonJia Modify rt_slist_foreach to rt_slist_for_each_entry.\n * Make code cleanup.\n */\n\n#ifndef __RT_SERVICE_H__\n#define __RT_SERVICE_H__\n\n#include <rtdef.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/**\n * @addtogroup KernelService\n */\n\n/**@{*/\n\n/**\n * rt_container_of - return the start address of struct type, while ptr is the\n * member of struct type.\n */\n#define rt_container_of(ptr, type, member) \\\n ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))\n\n\n/**\n * @brief initialize a list object\n */\n#define RT_LIST_OBJECT_INIT(object) { &(object), &(object) }\n\n/**\n * @brief initialize a list\n *\n * @param l list to be initialized\n */\nrt_inline void rt_list_init(rt_list_t *l)\n{\n l->next = l->prev = l;\n}\n\n/**\n * @brief insert a node after a list\n *\n * @param l list to insert it\n * @param n new node to be inserted\n */\nrt_inline void rt_list_insert_after(rt_list_t *l, rt_list_t *n)\n{\n l->next->prev = n;\n n->next = l->next;\n\n l->next = n;\n n->prev = l;\n}\n\n/**\n * @brief insert a node before a list\n *\n * @param n new node to be inserted\n * @param l list to insert it\n */\nrt_inline void rt_list_insert_before(rt_list_t *l, rt_list_t *n)\n{\n l->prev->next = n;\n n->prev = l->prev;\n\n l->prev = n;\n n->next = l;\n}\n\n/**\n * @brief remove node from list.\n * @param n the node to remove from the list.\n */\nrt_inline void rt_list_remove(rt_list_t *n)\n{\n n->next->prev = n->prev;\n n->prev->next = n->next;\n\n n->next = n->prev = n;\n}\n\n/**\n * @brief tests whether a list is empty\n * @param l the list to test.\n */\nrt_inline int rt_list_isempty(const rt_list_t *l)\n{\n return l->next == l;\n}\n\n/**\n * @brief get the list length\n * @param l the list to get.\n */\nrt_inline unsigned int rt_list_len(const rt_list_t *l)\n{\n unsigned int len = 0;\n const rt_list_t *p = l;\n while (p->next != l)\n {\n p = p->next;\n len ++;\n }\n\n return len;\n}\n\n/**\n * @brief get the struct for this entry\n * @param node the entry point\n * @param type the type of structure\n * @param member the name of list in structure\n */\n#define rt_list_entry(node, type, member) \\\n rt_container_of(node, type, member)\n\n/**\n * rt_list_for_each - iterate over a list\n * @param pos the rt_list_t * to use as a loop cursor.\n * @param head the head for your list.\n */\n#define rt_list_for_each(pos, head) \\\n for (pos = (head)->next; pos != (head); pos = pos->next)\n\n/**\n * rt_list_for_each_safe - iterate over a list safe against removal of list entry\n * @param pos the rt_list_t * to use as a loop cursor.\n * @param n another rt_list_t * to use as temporary storage\n * @param head the head for your list.\n */\n#define rt_list_for_each_safe(pos, n, head) \\\n for (pos = (head)->next, n = pos->next; pos != (head); \\\n pos = n, n = pos->next)\n\n/**\n * rt_list_for_each_entry - iterate over list of given type\n * @param pos the type * to use as a loop cursor.\n * @param head the head for your list.\n * @param member the name of the list_struct within the struct.\n */\n#define rt_list_for_each_entry(pos, head, member) \\\n for (pos = rt_list_entry((head)->next, rt_typeof(*pos), member); \\\n &pos->member != (head); \\\n pos = rt_list_entry(pos->member.next, rt_typeof(*pos), member))\n\n/**\n * rt_list_for_each_entry_safe - iterate over list of given type safe against removal of list entry\n * @param pos the type * to use as a loop cursor.\n * @param n another type * to use as temporary storage\n * @param head the head for your list.\n * @param member the name of the list_struct within the struct.\n */\n#define rt_list_for_each_entry_safe(pos, n, head, member) \\\n for (pos = rt_list_entry((head)->next, rt_typeof(*pos), member), \\\n n = rt_list_entry(pos->member.next, rt_typeof(*pos), member); \\\n &pos->member != (head); \\\n pos = n, n = rt_list_entry(n->member.next, rt_typeof(*n), member))\n\n/**\n * rt_list_first_entry - get the first element from a list\n * @param ptr the list head to take the element from.\n * @param type the type of the struct this is embedded in.\n * @param member the name of the list_struct within the struct.\n *\n * Note, that list is expected to be not empty.\n */\n#define rt_list_first_entry(ptr, type, member) \\\n rt_list_entry((ptr)->next, type, member)\n\n#define RT_SLIST_OBJECT_INIT(object) { RT_NULL }\n\n/**\n * @brief initialize a single list\n *\n * @param l the single list to be initialized\n */\nrt_inline void rt_slist_init(rt_slist_t *l)\n{\n l->next = RT_NULL;\n}\n\nrt_inline void rt_slist_append(rt_slist_t *l, rt_slist_t *n)\n{\n struct rt_slist_node *node;\n\n node = l;\n while (node->next) node = node->next;\n\n /* append the node to the tail */\n node->next = n;\n n->next = RT_NULL;\n}\n\nrt_inline void rt_slist_insert(rt_slist_t *l, rt_slist_t *n)\n{\n n->next = l->next;\n l->next = n;\n}\n\nrt_inline unsigned int rt_slist_len(const rt_slist_t *l)\n{\n unsigned int len = 0;\n const rt_slist_t *list = l->next;\n while (list != RT_NULL)\n {\n list = list->next;\n len ++;\n }\n\n return len;\n}\n\nrt_inline rt_slist_t *rt_slist_remove(rt_slist_t *l, rt_slist_t *n)\n{\n /* remove slist head */\n struct rt_slist_node *node = l;\n while (node->next && node->next != n) node = node->next;\n\n /* remove node */\n if (node->next != (rt_slist_t *)0) node->next = node->next->next;\n\n return l;\n}\n\nrt_inline rt_slist_t *rt_slist_first(rt_slist_t *l)\n{\n return l->next;\n}\n\nrt_inline rt_slist_t *rt_slist_tail(rt_slist_t *l)\n{\n while (l->next) l = l->next;\n\n return l;\n}\n\nrt_inline rt_slist_t *rt_slist_next(rt_slist_t *n)\n{\n return n->next;\n}\n\nrt_inline int rt_slist_isempty(rt_slist_t *l)\n{\n return l->next == RT_NULL;\n}\n\n/**\n * @brief get the struct for this single list node\n * @param node the entry point\n * @param type the type of structure\n * @param member the name of list in structure\n */\n#define rt_slist_entry(node, type, member) \\\n rt_container_of(node, type, member)\n\n/**\n * rt_slist_for_each - iterate over a single list\n * @param pos the rt_slist_t * to use as a loop cursor.\n * @param head the head for your single list.\n */\n#define rt_slist_for_each(pos, head) \\\n for (pos = (head)->next; pos != RT_NULL; pos = pos->next)\n\n/**\n * rt_slist_for_each_entry - iterate over single list of given type\n * @param pos the type * to use as a loop cursor.\n * @param head the head for your single list.\n * @param member the name of the list_struct within the struct.\n */\n#define rt_slist_for_each_entry(pos, head, member) \\\n for (pos = ((head)->next == (RT_NULL) ? (RT_NULL) : rt_slist_entry((head)->next, rt_typeof(*pos), member)); \\\n pos != (RT_NULL) && &pos->member != (RT_NULL); \\\n pos = (pos->member.next == (RT_NULL) ? (RT_NULL) : rt_slist_entry(pos->member.next, rt_typeof(*pos), member)))\n\n/**\n * rt_slist_first_entry - get the first element from a slist\n * @param ptr the slist head to take the element from.\n * @param type the type of the struct this is embedded in.\n * @param member the name of the slist_struct within the struct.\n *\n * Note, that slist is expected to be not empty.\n */\n#define rt_slist_first_entry(ptr, type, member) \\\n rt_slist_entry((ptr)->next, type, member)\n\n/**\n * rt_slist_tail_entry - get the tail element from a slist\n * @param ptr the slist head to take the element from.\n * @param type the type of the struct this is embedded in.\n * @param member the name of the slist_struct within the struct.\n *\n * Note, that slist is expected to be not empty.\n */\n#define rt_slist_tail_entry(ptr, type, member) \\\n rt_slist_entry(rt_slist_tail(ptr), type, member)\n\n/**@}*/\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n", "include/rtatomic.h": "/*\n * Copyright (c) 2006-2023, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2023-03-14 WangShun first version\n * 2023-05-20 Bernard add stdc atomic detection.\n */\n#ifndef __RT_ATOMIC_H__\n#define __RT_ATOMIC_H__\n\n#include <rthw.h>\n\n#if !defined(__cplusplus)\n\nrt_atomic_t rt_hw_atomic_load(volatile rt_atomic_t *ptr);\nvoid rt_hw_atomic_store(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_add(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_sub(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_and(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_or(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_xor(volatile rt_atomic_t *ptr, rt_atomic_t val);\nrt_atomic_t rt_hw_atomic_exchange(volatile rt_atomic_t *ptr, rt_atomic_t val);\nvoid rt_hw_atomic_flag_clear(volatile rt_atomic_t *ptr);\nrt_atomic_t rt_hw_atomic_flag_test_and_set(volatile rt_atomic_t *ptr);\nrt_atomic_t rt_hw_atomic_compare_exchange_strong(volatile rt_atomic_t *ptr, rt_atomic_t *expected, rt_atomic_t desired);\n\n#if defined(RT_USING_HW_ATOMIC)\n#define rt_atomic_load(ptr) rt_hw_atomic_load(ptr)\n#define rt_atomic_store(ptr, v) rt_hw_atomic_store(ptr, v)\n#define rt_atomic_add(ptr, v) rt_hw_atomic_add(ptr, v)\n#define rt_atomic_sub(ptr, v) rt_hw_atomic_sub(ptr, v)\n#define rt_atomic_and(ptr, v) rt_hw_atomic_and(ptr, v)\n#define rt_atomic_or(ptr, v) rt_hw_atomic_or(ptr, v)\n#define rt_atomic_xor(ptr, v) rt_hw_atomic_xor(ptr, v)\n#define rt_atomic_exchange(ptr, v) rt_hw_atomic_exchange(ptr, v)\n#define rt_atomic_flag_clear(ptr) rt_hw_atomic_flag_clear(ptr)\n#define rt_atomic_flag_test_and_set(ptr) rt_hw_atomic_flag_test_and_set(ptr)\n#define rt_atomic_compare_exchange_strong(ptr, v,des) rt_hw_atomic_compare_exchange_strong(ptr, v ,des)\n\n#elif defined(RT_USING_STDC_ATOMIC)\n\n#ifndef __STDC_NO_ATOMICS__\n#define rt_atomic_load(ptr) atomic_load(ptr)\n#define rt_atomic_store(ptr, v) atomic_store(ptr, v)\n#define rt_atomic_add(ptr, v) atomic_fetch_add(ptr, v)\n#define rt_atomic_sub(ptr, v) atomic_fetch_sub(ptr, v)\n#define rt_atomic_and(ptr, v) atomic_fetch_and(ptr, v)\n#define rt_atomic_or(ptr, v) atomic_fetch_or(ptr, v)\n#define rt_atomic_xor(ptr, v) atomic_fetch_xor(ptr, v)\n#define rt_atomic_exchange(ptr, v) atomic_exchange(ptr, v)\n#define rt_atomic_flag_clear(ptr) atomic_flag_clear(ptr)\n#define rt_atomic_flag_test_and_set(ptr) atomic_flag_test_and_set(ptr)\n#define rt_atomic_compare_exchange_strong(ptr, v,des) atomic_compare_exchange_strong(ptr, v ,des)\n#else\n#error \"The standard library C doesn't support the atomic operation\"\n#endif /* __STDC_NO_ATOMICS__ */\n\n#else\n#include <rthw.h>\n#define rt_atomic_load(ptr) rt_soft_atomic_load(ptr)\n#define rt_atomic_store(ptr, v) rt_soft_atomic_store(ptr, v)\n#define rt_atomic_add(ptr, v) rt_soft_atomic_add(ptr, v)\n#define rt_atomic_sub(ptr, v) rt_soft_atomic_sub(ptr, v)\n#define rt_atomic_and(ptr, v) rt_soft_atomic_and(ptr, v)\n#define rt_atomic_or(ptr, v) rt_soft_atomic_or(ptr, v)\n#define rt_atomic_xor(ptr, v) rt_soft_atomic_xor(ptr, v)\n#define rt_atomic_exchange(ptr, v) rt_soft_atomic_exchange(ptr, v)\n#define rt_atomic_flag_clear(ptr) rt_soft_atomic_flag_clear(ptr)\n#define rt_atomic_flag_test_and_set(ptr) rt_soft_atomic_flag_test_and_set(ptr)\n#define rt_atomic_compare_exchange_strong(ptr, v,des) rt_soft_atomic_compare_exchange_strong(ptr, v ,des)\n\nrt_inline rt_atomic_t rt_soft_atomic_exchange(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr = val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_add(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr += val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_sub(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr -= val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_xor(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr = (*ptr) ^ val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_and(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr = (*ptr) & val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_or(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n *ptr = (*ptr) | val;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_load(volatile rt_atomic_t *ptr)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n temp = *ptr;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline void rt_soft_atomic_store(volatile rt_atomic_t *ptr, rt_atomic_t val)\n{\n rt_base_t level;\n level = rt_hw_interrupt_disable();\n *ptr = val;\n rt_hw_interrupt_enable(level);\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_flag_test_and_set(volatile rt_atomic_t *ptr)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n if (*ptr == 0)\n {\n temp = 0;\n *ptr = 1;\n }\n else\n temp = 1;\n rt_hw_interrupt_enable(level);\n return temp;\n}\n\nrt_inline void rt_soft_atomic_flag_clear(volatile rt_atomic_t *ptr)\n{\n rt_base_t level;\n level = rt_hw_interrupt_disable();\n *ptr = 0;\n rt_hw_interrupt_enable(level);\n}\n\nrt_inline rt_atomic_t rt_soft_atomic_compare_exchange_strong(volatile rt_atomic_t *ptr1, rt_atomic_t *ptr2,\n rt_atomic_t desired)\n{\n rt_base_t level;\n rt_atomic_t temp;\n level = rt_hw_interrupt_disable();\n if ((*ptr1) != (*ptr2))\n {\n *ptr2 = *ptr1;\n temp = 0;\n }\n else\n {\n *ptr1 = desired;\n temp = 1;\n }\n rt_hw_interrupt_enable(level);\n return temp;\n}\n#endif /* RT_USING_STDC_ATOMIC */\n\nrt_inline rt_bool_t rt_atomic_dec_and_test(volatile rt_atomic_t *ptr)\n{\n return rt_atomic_sub(ptr, 1) == 0;\n}\n\nrt_inline rt_atomic_t rt_atomic_fetch_add_unless(volatile rt_atomic_t *ptr, rt_atomic_t a, rt_atomic_t u)\n{\n rt_atomic_t c = rt_atomic_load(ptr);\n\n do {\n if (c == u)\n {\n break;\n }\n } while (!rt_atomic_compare_exchange_strong(ptr, &c, c + a));\n\n return c;\n}\n\nrt_inline rt_bool_t rt_atomic_add_unless(volatile rt_atomic_t *ptr, rt_atomic_t a, rt_atomic_t u)\n{\n return rt_atomic_fetch_add_unless(ptr, a, u) != u;\n}\n\nrt_inline rt_bool_t rt_atomic_inc_not_zero(volatile rt_atomic_t *ptr)\n{\n return rt_atomic_add_unless(ptr, 1, 0);\n}\n\n#endif /* __cplusplus */\n\n#endif /* __RT_ATOMIC_H__ */\n", "include/rthw.h": "/*\n * Copyright (c) 2006-2021, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2006-03-18 Bernard the first version\n * 2006-04-25 Bernard add rt_hw_context_switch_interrupt declaration\n * 2006-09-24 Bernard add rt_hw_context_switch_to declaration\n * 2012-12-29 Bernard add rt_hw_exception_install declaration\n * 2017-10-17 Hichard add some macros\n * 2018-11-17 Jesven add rt_hw_spinlock_t\n * add smp support\n * 2019-05-18 Bernard add empty definition for not enable cache case\n * 2023-09-15 xqyjlj perf rt_hw_interrupt_disable/enable\n * 2023-10-16 Shell Support a new backtrace framework\n */\n\n#ifndef __RT_HW_H__\n#define __RT_HW_H__\n\n#include <rtdef.h>\n\n#if defined (RT_USING_CACHE) || defined(RT_USING_SMP)\n#include <cpuport.h> /* include spinlock, cache ops, etc. */\n#endif\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/*\n * Some macros define\n */\n#ifndef HWREG64\n#define HWREG64(x) (*((volatile rt_uint64_t *)(x)))\n#endif\n#ifndef HWREG32\n#define HWREG32(x) (*((volatile rt_uint32_t *)(x)))\n#endif\n#ifndef HWREG16\n#define HWREG16(x) (*((volatile rt_uint16_t *)(x)))\n#endif\n#ifndef HWREG8\n#define HWREG8(x) (*((volatile rt_uint8_t *)(x)))\n#endif\n\n#ifndef RT_CPU_CACHE_LINE_SZ\n#define RT_CPU_CACHE_LINE_SZ 32\n#endif\n\nenum RT_HW_CACHE_OPS\n{\n RT_HW_CACHE_FLUSH = 0x01,\n RT_HW_CACHE_INVALIDATE = 0x02,\n};\n\n/*\n * CPU interfaces\n */\n#ifdef RT_USING_CACHE\n\n#ifdef RT_USING_SMART\n#include <cache.h>\n#endif\n\nvoid rt_hw_cpu_icache_enable(void);\nvoid rt_hw_cpu_icache_disable(void);\nrt_base_t rt_hw_cpu_icache_status(void);\nvoid rt_hw_cpu_icache_ops(int ops, void* addr, int size);\n\nvoid rt_hw_cpu_dcache_enable(void);\nvoid rt_hw_cpu_dcache_disable(void);\nrt_base_t rt_hw_cpu_dcache_status(void);\nvoid rt_hw_cpu_dcache_ops(int ops, void* addr, int size);\n#else\n\n/* define cache ops as empty */\n#define rt_hw_cpu_icache_enable(...)\n#define rt_hw_cpu_icache_disable(...)\n#define rt_hw_cpu_icache_ops(...)\n#define rt_hw_cpu_dcache_enable(...)\n#define rt_hw_cpu_dcache_disable(...)\n#define rt_hw_cpu_dcache_ops(...)\n\n#define rt_hw_cpu_icache_status(...) 0\n#define rt_hw_cpu_dcache_status(...) 0\n\n#endif\n\nvoid rt_hw_cpu_reset(void);\nvoid rt_hw_cpu_shutdown(void);\n\nconst char *rt_hw_cpu_arch(void);\n\nrt_uint8_t *rt_hw_stack_init(void *entry,\n void *parameter,\n rt_uint8_t *stack_addr,\n void *exit);\n\n#ifdef RT_USING_HW_STACK_GUARD\nvoid rt_hw_stack_guard_init(rt_thread_t thread);\n#endif\n\n/*\n * Interrupt handler definition\n */\ntypedef void (*rt_isr_handler_t)(int vector, void *param);\n\nstruct rt_irq_desc\n{\n rt_isr_handler_t handler;\n void *param;\n\n#ifdef RT_USING_INTERRUPT_INFO\n char name[RT_NAME_MAX];\n rt_uint32_t counter;\n#ifdef RT_USING_SMP\n rt_ubase_t cpu_counter[RT_CPUS_NR];\n#endif\n#endif\n};\n\n/*\n * Interrupt interfaces\n */\nvoid rt_hw_interrupt_init(void);\nvoid rt_hw_interrupt_mask(int vector);\nvoid rt_hw_interrupt_umask(int vector);\nrt_isr_handler_t rt_hw_interrupt_install(int vector,\n rt_isr_handler_t handler,\n void *param,\n const char *name);\n\n#ifdef RT_USING_SMP\nrt_base_t rt_hw_local_irq_disable(void);\nvoid rt_hw_local_irq_enable(rt_base_t level);\n\nrt_base_t rt_cpus_lock(void);\nvoid rt_cpus_unlock(rt_base_t level);\n\n#define rt_hw_interrupt_disable rt_cpus_lock\n#define rt_hw_interrupt_enable rt_cpus_unlock\n#else\nrt_base_t rt_hw_interrupt_disable(void);\nvoid rt_hw_interrupt_enable(rt_base_t level);\n\n#define rt_hw_local_irq_disable rt_hw_interrupt_disable\n#define rt_hw_local_irq_enable rt_hw_interrupt_enable\n\n#endif /*RT_USING_SMP*/\nrt_bool_t rt_hw_interrupt_is_disabled(void);\n\n/*\n * Context interfaces\n */\n#ifdef RT_USING_SMP\nvoid rt_hw_context_switch(rt_ubase_t from, rt_ubase_t to, struct rt_thread *to_thread);\nvoid rt_hw_context_switch_to(rt_ubase_t to, struct rt_thread *to_thread);\nvoid rt_hw_context_switch_interrupt(void *context, rt_ubase_t from, rt_ubase_t to, struct rt_thread *to_thread);\n#else\nvoid rt_hw_context_switch(rt_ubase_t from, rt_ubase_t to);\nvoid rt_hw_context_switch_to(rt_ubase_t to);\nvoid rt_hw_context_switch_interrupt(rt_ubase_t from, rt_ubase_t to, rt_thread_t from_thread, rt_thread_t to_thread);\n#endif /*RT_USING_SMP*/\n\n/**\n * Hardware Layer Backtrace Service\n */\nstruct rt_hw_backtrace_frame {\n rt_base_t fp;\n rt_base_t pc;\n};\n\nrt_err_t rt_hw_backtrace_frame_get(rt_thread_t thread, struct rt_hw_backtrace_frame *frame);\n\nrt_err_t rt_hw_backtrace_frame_unwind(rt_thread_t thread, struct rt_hw_backtrace_frame *frame);\n\nvoid rt_hw_console_output(const char *str);\n\nvoid rt_hw_show_memory(rt_uint32_t addr, rt_size_t size);\n\n/*\n * Exception interfaces\n */\nvoid rt_hw_exception_install(rt_err_t (*exception_handle)(void *context));\n\n/*\n * delay interfaces\n */\nvoid rt_hw_us_delay(rt_uint32_t us);\n\nint rt_hw_cpu_id(void);\n\n#if defined(RT_USING_SMP) || defined(RT_USING_AMP)\n/**\n * ipi function\n */\nvoid rt_hw_ipi_send(int ipi_vector, unsigned int cpu_mask);\n#endif\n\n#ifdef RT_USING_SMP\n\nvoid rt_hw_spin_lock_init(rt_hw_spinlock_t *lock);\nvoid rt_hw_spin_lock(rt_hw_spinlock_t *lock);\nvoid rt_hw_spin_unlock(rt_hw_spinlock_t *lock);\n\nextern rt_hw_spinlock_t _cpus_lock;\n\n#define __RT_HW_SPIN_LOCK_INITIALIZER(lockname) {0}\n\n#define __RT_HW_SPIN_LOCK_UNLOCKED(lockname) \\\n (rt_hw_spinlock_t) __RT_HW_SPIN_LOCK_INITIALIZER(lockname)\n\n#define RT_DEFINE_HW_SPINLOCK(x) rt_hw_spinlock_t x = __RT_HW_SPIN_LOCK_UNLOCKED(x)\n\n/**\n * boot secondary cpu\n */\nvoid rt_hw_secondary_cpu_up(void);\n\n/**\n * secondary cpu idle function\n */\nvoid rt_hw_secondary_cpu_idle_exec(void);\n#else\n\n#define RT_DEFINE_HW_SPINLOCK(x) rt_ubase_t x\n\n#define rt_hw_spin_lock(lock) *(lock) = rt_hw_interrupt_disable()\n#define rt_hw_spin_unlock(lock) rt_hw_interrupt_enable(*(lock))\n\n\n#endif\n\n#ifndef RT_USING_CACHE\n#define rt_hw_isb()\n#define rt_hw_dmb()\n#define rt_hw_dsb()\n#endif\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n", "include/rtm.h": "/*\n * Copyright (c) 2006-2021, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n */\n\n#ifndef __RTM_H__\n#define __RTM_H__\n\n#include <rtdef.h>\n#include <rtthread.h>\n\n#ifdef RT_USING_MODULE\nstruct rt_module_symtab\n{\n void *addr;\n const char *name;\n};\n\n#if defined(_MSC_VER)\n#pragma section(\"RTMSymTab$f\",read)\n#define RTM_EXPORT(symbol) \\\n__declspec(allocate(\"RTMSymTab$f\"))const char __rtmsym_##symbol##_name[] = \"__vs_rtm_\"#symbol;\n#pragma comment(linker, \"/merge:RTMSymTab=mytext\")\n\n#elif defined(__MINGW32__)\n#define RTM_EXPORT(symbol)\n\n#else\n#define RTM_EXPORT(symbol) \\\nconst char __rtmsym_##symbol##_name[] rt_section(\".rodata.name\") = #symbol; \\\nconst struct rt_module_symtab __rtmsym_##symbol rt_section(\"RTMSymTab\")= \\\n{ \\\n (void *)&symbol, \\\n __rtmsym_##symbol##_name \\\n};\n#endif\n\n#else\n#define RTM_EXPORT(symbol)\n#endif\n\n#endif\n", "include/rttypes.h": "/*\n * Copyright (c) 2006-2024, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2024-01-18 Shell Separate the basic types from rtdef.h\n */\n\n#ifndef __RT_TYPES_H__\n#define __RT_TYPES_H__\n\n#include <rtconfig.h>\n\n#include <stdint.h>\n#include <stddef.h>\n#include <stdarg.h>\n#ifndef RT_USING_NANO\n#include <sys/types.h>\n#include <sys/errno.h>\n#if defined(RT_USING_SIGNALS) || defined(RT_USING_SMART)\n#include <sys/signal.h>\n#endif /* defined(RT_USING_SIGNALS) || defined(RT_USING_SMART) */\n#endif /* RT_USING_NANO */\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/**\n * RT-Thread basic data types definition\n */\n\ntypedef int rt_bool_t; /**< boolean type */\ntypedef signed long rt_base_t; /**< Nbit CPU related date type */\ntypedef unsigned long rt_ubase_t; /**< Nbit unsigned CPU related data type */\n\n#ifndef RT_USING_ARCH_DATA_TYPE\n#ifdef RT_USING_LIBC\ntypedef int8_t rt_int8_t; /**< 8bit integer type */\ntypedef int16_t rt_int16_t; /**< 16bit integer type */\ntypedef int32_t rt_int32_t; /**< 32bit integer type */\ntypedef uint8_t rt_uint8_t; /**< 8bit unsigned integer type */\ntypedef uint16_t rt_uint16_t; /**< 16bit unsigned integer type */\ntypedef uint32_t rt_uint32_t; /**< 32bit unsigned integer type */\ntypedef int64_t rt_int64_t; /**< 64bit integer type */\ntypedef uint64_t rt_uint64_t; /**< 64bit unsigned integer type */\n#else\ntypedef signed char rt_int8_t; /**< 8bit integer type */\ntypedef signed short rt_int16_t; /**< 16bit integer type */\ntypedef signed int rt_int32_t; /**< 32bit integer type */\ntypedef unsigned char rt_uint8_t; /**< 8bit unsigned integer type */\ntypedef unsigned short rt_uint16_t; /**< 16bit unsigned integer type */\ntypedef unsigned int rt_uint32_t; /**< 32bit unsigned integer type */\n#ifdef ARCH_CPU_64BIT\ntypedef signed long rt_int64_t; /**< 64bit integer type */\ntypedef unsigned long rt_uint64_t; /**< 64bit unsigned integer type */\n#else\ntypedef signed long long rt_int64_t; /**< 64bit integer type */\ntypedef unsigned long long rt_uint64_t; /**< 64bit unsigned integer type */\n#endif /* ARCH_CPU_64BIT */\n#endif /* RT_USING_LIBC */\n#endif /* RT_USING_ARCH_DATA_TYPE */\n\n#if defined(RT_USING_LIBC) && !defined(RT_USING_NANO)\ntypedef size_t rt_size_t; /**< Type for size number */\ntypedef ssize_t rt_ssize_t; /**< Used for a count of bytes or an error indication */\n#else\ntypedef rt_ubase_t rt_size_t; /**< Type for size number */\ntypedef rt_base_t rt_ssize_t; /**< Used for a count of bytes or an error indication */\n#endif /* defined(RT_USING_LIBC) && !defined(RT_USING_NANO) */\n\ntypedef rt_base_t rt_err_t; /**< Type for error number */\ntypedef rt_uint32_t rt_time_t; /**< Type for time stamp */\ntypedef rt_uint32_t rt_tick_t; /**< Type for tick count */\ntypedef rt_base_t rt_flag_t; /**< Type for flags */\ntypedef rt_ubase_t rt_dev_t; /**< Type for device */\ntypedef rt_base_t rt_off_t; /**< Type for offset */\n\n#ifdef __cplusplus\n typedef rt_base_t rt_atomic_t;\n#else\n #if defined(RT_USING_HW_ATOMIC)\n typedef rt_base_t rt_atomic_t;\n #elif defined(RT_USING_STDC_ATOMIC)\n #include <stdatomic.h>\n typedef atomic_intptr_t rt_atomic_t;\n #else\n typedef rt_base_t rt_atomic_t;\n #endif /* RT_USING_STDC_ATOMIC */\n#endif /* __cplusplus */\n\n/* boolean type definitions */\n#define RT_TRUE 1 /**< boolean true */\n#define RT_FALSE 0 /**< boolean fails */\n\n/* null pointer definition */\n#define RT_NULL 0\n\n/**\n * Double List structure\n */\nstruct rt_list_node\n{\n struct rt_list_node *next; /**< point to next node. */\n struct rt_list_node *prev; /**< point to prev node. */\n};\ntypedef struct rt_list_node rt_list_t; /**< Type for lists. */\n\n/**\n * Single List structure\n */\nstruct rt_slist_node\n{\n struct rt_slist_node *next; /**< point to next node. */\n};\ntypedef struct rt_slist_node rt_slist_t; /**< Type for single list. */\n\n/**\n * Spinlock\n */\n#ifdef RT_USING_SMP\n#include <cpuport.h> /* for spinlock from arch */\n\nstruct rt_spinlock\n{\n rt_hw_spinlock_t lock;\n#ifdef RT_USING_DEBUG\n rt_uint32_t critical_level;\n#endif /* RT_USING_DEBUG */\n#if defined(RT_DEBUGING_SPINLOCK)\n void *owner;\n void *pc;\n#endif /* RT_DEBUGING_SPINLOCK */\n};\n\n#ifdef RT_DEBUGING_SPINLOCK\n\n#define __OWNER_MAGIC ((void *)0xdeadbeaf)\n\n#if defined(__GNUC__)\n#define __GET_RETURN_ADDRESS __builtin_return_address(0)\n#else\n#define __GET_RETURN_ADDRESS RT_NULL\n#endif\n\n#define _SPIN_LOCK_DEBUG_OWNER(lock) \\\n do \\\n { \\\n struct rt_thread *_curthr = rt_thread_self(); \\\n if (_curthr != RT_NULL) \\\n { \\\n (lock)->owner = _curthr; \\\n (lock)->pc = __GET_RETURN_ADDRESS; \\\n } \\\n } while (0)\n\n#define _SPIN_UNLOCK_DEBUG_OWNER(lock) \\\n do \\\n { \\\n (lock)->owner = __OWNER_MAGIC; \\\n (lock)->pc = RT_NULL; \\\n } while (0)\n\n#else\n\n#define _SPIN_LOCK_DEBUG_OWNER(lock)\n#define _SPIN_UNLOCK_DEBUG_OWNER(lock)\n#endif\n\n#ifdef RT_USING_DEBUG\n\n#define _SPIN_LOCK_DEBUG_CRITICAL(lock) \\\n do \\\n { \\\n struct rt_thread *_curthr = rt_thread_self(); \\\n if (_curthr != RT_NULL) \\\n { \\\n (lock)->critical_level = rt_critical_level(); \\\n } \\\n } while (0)\n\n#define _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical) \\\n do \\\n { \\\n (critical) = (lock)->critical_level; \\\n } while (0)\n\n#else\n\n#define _SPIN_LOCK_DEBUG_CRITICAL(lock)\n#define _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical) (critical = 0)\n#endif /* RT_USING_DEBUG */\n\n#define RT_SPIN_LOCK_DEBUG(lock) \\\n do \\\n { \\\n _SPIN_LOCK_DEBUG_OWNER(lock); \\\n _SPIN_LOCK_DEBUG_CRITICAL(lock); \\\n } while (0)\n\n#define RT_SPIN_UNLOCK_DEBUG(lock, critical) \\\n do \\\n { \\\n _SPIN_UNLOCK_DEBUG_OWNER(lock); \\\n _SPIN_UNLOCK_DEBUG_CRITICAL(lock, critical); \\\n } while (0)\n\n#ifndef RT_SPINLOCK_INIT\n#define RT_SPINLOCK_INIT {{0}} /* can be overridden by cpuport.h */\n#endif /* RT_SPINLOCK_INIT */\n\n#else\n\nstruct rt_spinlock\n{\n#ifdef RT_USING_DEBUG\n rt_uint32_t critical_level;\n#endif /* RT_USING_DEBUG */\n rt_ubase_t lock;\n};\n#define RT_SPINLOCK_INIT {0}\n#endif /* RT_USING_SMP */\n\ntypedef struct rt_spinlock rt_spinlock_t;\n\n#define RT_DEFINE_SPINLOCK(x) struct rt_spinlock x = RT_SPINLOCK_INIT\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __RT_TYPES_H__ */\n", "include/rtcompiler.h": "/*\n * Copyright (c) 2006-2024, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2024-01-18 Shell Separate the compiler porting from rtdef.h\n */\n#ifndef __RT_COMPILER_H__\n#define __RT_COMPILER_H__\n\n#include <rtconfig.h>\n\n#if defined(__ARMCC_VERSION) /* ARM Compiler */\n#define rt_section(x) __attribute__((section(x)))\n#define rt_used __attribute__((used))\n#define rt_align(n) __attribute__((aligned(n)))\n#define rt_weak __attribute__((weak))\n#define rt_typeof typeof\n#define rt_noreturn\n#define rt_inline static __inline\n#define rt_always_inline rt_inline\n#elif defined (__IAR_SYSTEMS_ICC__) /* for IAR Compiler */\n#define rt_section(x) @ x\n#define rt_used __root\n#define PRAGMA(x) _Pragma(#x)\n#define rt_align(n) PRAGMA(data_alignment=n)\n#define rt_weak __weak\n#define rt_typeof __typeof\n#define rt_noreturn\n#define rt_inline static inline\n#define rt_always_inline rt_inline\n#elif defined (__GNUC__) /* GNU GCC Compiler */\n#define __RT_STRINGIFY(x...) #x\n#define RT_STRINGIFY(x...) __RT_STRINGIFY(x)\n#define rt_section(x) __attribute__((section(x)))\n#define rt_used __attribute__((used))\n#define rt_align(n) __attribute__((aligned(n)))\n#define rt_weak __attribute__((weak))\n#define rt_typeof __typeof__\n#define rt_noreturn __attribute__ ((noreturn))\n#define rt_inline static __inline\n#define rt_always_inline static inline __attribute__((always_inline))\n#elif defined (__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */\n#define rt_section(x) __attribute__((section(x)))\n#define rt_used __attribute__((used))\n#define rt_align(n) __attribute__((aligned(n)))\n#define rt_weak __attribute__((weak))\n#define rt_typeof typeof\n#define rt_noreturn\n#define rt_inline static inline\n#define rt_always_inline rt_inline\n#elif defined (_MSC_VER) /* for Visual Studio Compiler */\n#define rt_section(x)\n#define rt_used\n#define rt_align(n) __declspec(align(n))\n#define rt_weak\n#define rt_typeof typeof\n#define rt_noreturn\n#define rt_inline static __inline\n#define rt_always_inline rt_inline\n#elif defined (__TI_COMPILER_VERSION__) /* for TI CCS Compiler */\n/**\n * The way that TI compiler set section is different from other(at least\n * GCC and MDK) compilers. See ARM Optimizing C/C++ Compiler 5.9.3 for more\n * details.\n */\n#define rt_section(x) __attribute__((section(x)))\n#ifdef __TI_EABI__\n#define rt_used __attribute__((retain)) __attribute__((used))\n#else\n#define rt_used __attribute__((used))\n#endif\n#define PRAGMA(x) _Pragma(#x)\n#define rt_align(n) __attribute__((aligned(n)))\n#ifdef __TI_EABI__\n#define rt_weak __attribute__((weak))\n#else\n#define rt_weak\n#endif\n#define rt_typeof typeof\n#define rt_noreturn\n#define rt_inline static inline\n#define rt_always_inline rt_inline\n#elif defined (__TASKING__) /* for TASKING Compiler */\n#define rt_section(x) __attribute__((section(x)))\n#define rt_used __attribute__((used, protect))\n#define PRAGMA(x) _Pragma(#x)\n#define rt_align(n) __attribute__((__align(n)))\n#define rt_weak __attribute__((weak))\n#define rt_typeof typeof\n#define rt_noreturn\n#define rt_inline static inline\n#define rt_always_inline rt_inline\n#else /* Unkown Compiler */\n #error not supported tool chain\n#endif /* __ARMCC_VERSION */\n\n#endif /* __RT_COMPILER_H__ */\n", "include/rtthread.h": "/*\n * Copyright (c) 2006-2021, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2006-03-18 Bernard the first version\n * 2006-04-26 Bernard add semaphore APIs\n * 2006-08-10 Bernard add version information\n * 2007-01-28 Bernard rename RT_OBJECT_Class_Static to RT_Object_Class_Static\n * 2007-03-03 Bernard clean up the definitions to rtdef.h\n * 2010-04-11 yi.qiu add module feature\n * 2013-06-24 Bernard add rt_kprintf re-define when not use RT_USING_CONSOLE.\n * 2016-08-09 ArdaFu add new thread and interrupt hook.\n * 2018-11-22 Jesven add all cpu's lock and ipi handler\n * 2021-02-28 Meco Man add RT_KSERVICE_USING_STDLIB\n * 2021-11-14 Meco Man add rtlegacy.h for compatibility\n * 2022-06-04 Meco Man remove strnlen\n * 2023-05-20 Bernard add rtatomic.h header file to included files.\n * 2023-06-30 ChuShicheng move debug check from the rtdebug.h\n * 2023-10-16 Shell Support a new backtrace framework\n * 2023-12-10 xqyjlj fix spinlock in up\n * 2024-01-25 Shell Add rt_susp_list for IPC primitives\n * 2024-03-10 Meco Man move std libc related functions to rtklibc\n */\n\n#ifndef __RT_THREAD_H__\n#define __RT_THREAD_H__\n\n#include <rtconfig.h>\n#include <rtdef.h>\n#include <rtservice.h>\n#include <rtm.h>\n#include <rtatomic.h>\n#include <rtklibc.h>\n#ifdef RT_USING_LEGACY\n#include <rtlegacy.h>\n#endif\n#ifdef RT_USING_FINSH\n#include <finsh.h>\n#endif /* RT_USING_FINSH */\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n#ifdef __GNUC__\nint entry(void);\n#endif\n\n/**\n * @addtogroup KernelObject\n * @{\n */\n\n/*\n * kernel object interface\n */\nstruct rt_object_information *\nrt_object_get_information(enum rt_object_class_type type);\nint rt_object_get_length(enum rt_object_class_type type);\nint rt_object_get_pointers(enum rt_object_class_type type, rt_object_t *pointers, int maxlen);\n\nvoid rt_object_init(struct rt_object *object,\n enum rt_object_class_type type,\n const char *name);\nvoid rt_object_detach(rt_object_t object);\n#ifdef RT_USING_HEAP\nrt_object_t rt_object_allocate(enum rt_object_class_type type, const char *name);\nvoid rt_object_delete(rt_object_t object);\n/* custom object */\nrt_object_t rt_custom_object_create(const char *name, void *data, rt_err_t (*data_destroy)(void *));\nrt_err_t rt_custom_object_destroy(rt_object_t obj);\n#endif /* RT_USING_HEAP */\nrt_bool_t rt_object_is_systemobject(rt_object_t object);\nrt_uint8_t rt_object_get_type(rt_object_t object);\nrt_object_t rt_object_find(const char *name, rt_uint8_t type);\nrt_err_t rt_object_get_name(rt_object_t object, char *name, rt_uint8_t name_size);\n\n#ifdef RT_USING_HOOK\nvoid rt_object_attach_sethook(void (*hook)(struct rt_object *object));\nvoid rt_object_detach_sethook(void (*hook)(struct rt_object *object));\nvoid rt_object_trytake_sethook(void (*hook)(struct rt_object *object));\nvoid rt_object_take_sethook(void (*hook)(struct rt_object *object));\nvoid rt_object_put_sethook(void (*hook)(struct rt_object *object));\n#endif /* RT_USING_HOOK */\n\n/**@}*/\n\n/**\n * @addtogroup Clock\n * @{\n */\n\n/*\n * clock & timer interface\n */\nrt_tick_t rt_tick_get(void);\nvoid rt_tick_set(rt_tick_t tick);\nvoid rt_tick_increase(void);\nrt_tick_t rt_tick_from_millisecond(rt_int32_t ms);\nrt_tick_t rt_tick_get_millisecond(void);\n#ifdef RT_USING_HOOK\nvoid rt_tick_sethook(void (*hook)(void));\n#endif /* RT_USING_HOOK */\n\nvoid rt_system_timer_init(void);\nvoid rt_system_timer_thread_init(void);\n\nvoid rt_timer_init(rt_timer_t timer,\n const char *name,\n void (*timeout)(void *parameter),\n void *parameter,\n rt_tick_t time,\n rt_uint8_t flag);\nrt_err_t rt_timer_detach(rt_timer_t timer);\n#ifdef RT_USING_HEAP\nrt_timer_t rt_timer_create(const char *name,\n void (*timeout)(void *parameter),\n void *parameter,\n rt_tick_t time,\n rt_uint8_t flag);\nrt_err_t rt_timer_delete(rt_timer_t timer);\n#endif /* RT_USING_HEAP */\nrt_err_t rt_timer_start(rt_timer_t timer);\nrt_err_t rt_timer_stop(rt_timer_t timer);\nrt_err_t rt_timer_control(rt_timer_t timer, int cmd, void *arg);\nrt_tick_t rt_timer_next_timeout_tick(void);\nvoid rt_timer_check(void);\n#ifdef RT_USING_HOOK\nvoid rt_timer_enter_sethook(void (*hook)(struct rt_timer *timer));\nvoid rt_timer_exit_sethook(void (*hook)(struct rt_timer *timer));\n#endif /* RT_USING_HOOK */\n\n/**@}*/\n\n/**\n * @addtogroup Thread\n * @{\n */\n\n/*\n * thread interface\n */\nrt_err_t rt_thread_init(struct rt_thread *thread,\n const char *name,\n void (*entry)(void *parameter),\n void *parameter,\n void *stack_start,\n rt_uint32_t stack_size,\n rt_uint8_t priority,\n rt_uint32_t tick);\nrt_err_t rt_thread_detach(rt_thread_t thread);\n#ifdef RT_USING_HEAP\nrt_thread_t rt_thread_create(const char *name,\n void (*entry)(void *parameter),\n void *parameter,\n rt_uint32_t stack_size,\n rt_uint8_t priority,\n rt_uint32_t tick);\nrt_err_t rt_thread_delete(rt_thread_t thread);\n#endif /* RT_USING_HEAP */\nrt_thread_t rt_thread_self(void);\nrt_thread_t rt_thread_find(char *name);\nrt_err_t rt_thread_startup(rt_thread_t thread);\nrt_err_t rt_thread_yield(void);\nrt_err_t rt_thread_delay(rt_tick_t tick);\nrt_err_t rt_thread_delay_until(rt_tick_t *tick, rt_tick_t inc_tick);\nrt_err_t rt_thread_mdelay(rt_int32_t ms);\nrt_err_t rt_thread_control(rt_thread_t thread, int cmd, void *arg);\nrt_err_t rt_thread_suspend(rt_thread_t thread);\nrt_err_t rt_thread_suspend_with_flag(rt_thread_t thread, int suspend_flag);\nrt_err_t rt_thread_resume(rt_thread_t thread);\n#ifdef RT_USING_SMART\nrt_err_t rt_thread_wakeup(rt_thread_t thread);\nvoid rt_thread_wakeup_set(struct rt_thread *thread, rt_wakeup_func_t func, void* user_data);\n#endif /* RT_USING_SMART */\nrt_err_t rt_thread_get_name(rt_thread_t thread, char *name, rt_uint8_t name_size);\n#ifdef RT_USING_SIGNALS\nvoid rt_thread_alloc_sig(rt_thread_t tid);\nvoid rt_thread_free_sig(rt_thread_t tid);\nint rt_thread_kill(rt_thread_t tid, int sig);\n#endif /* RT_USING_SIGNALS */\n#ifdef RT_USING_HOOK\nvoid rt_thread_suspend_sethook(void (*hook)(rt_thread_t thread));\nvoid rt_thread_resume_sethook (void (*hook)(rt_thread_t thread));\n\n/**\n * @brief Sets a hook function when a thread is initialized.\n *\n * @param thread is the target thread that initializing\n */\ntypedef void (*rt_thread_inited_hookproto_t)(rt_thread_t thread);\nRT_OBJECT_HOOKLIST_DECLARE(rt_thread_inited_hookproto_t, rt_thread_inited);\n\n#endif /* RT_USING_HOOK */\n\n/*\n * idle thread interface\n */\nvoid rt_thread_idle_init(void);\n#if defined(RT_USING_HOOK) || defined(RT_USING_IDLE_HOOK)\nrt_err_t rt_thread_idle_sethook(void (*hook)(void));\nrt_err_t rt_thread_idle_delhook(void (*hook)(void));\n#endif /* defined(RT_USING_HOOK) || defined(RT_USING_IDLE_HOOK) */\nrt_thread_t rt_thread_idle_gethandler(void);\n\n/*\n * schedule service\n */\nvoid rt_system_scheduler_init(void);\nvoid rt_system_scheduler_start(void);\n\nvoid rt_schedule(void);\nvoid rt_scheduler_do_irq_switch(void *context);\n\n#ifdef RT_USING_OVERFLOW_CHECK\nvoid rt_scheduler_stack_check(struct rt_thread *thread);\n\n#define RT_SCHEDULER_STACK_CHECK(thr) rt_scheduler_stack_check(thr)\n\n#else /* !RT_USING_OVERFLOW_CHECK */\n\n#define RT_SCHEDULER_STACK_CHECK(thr)\n\n#endif /* RT_USING_OVERFLOW_CHECK */\n\nrt_base_t rt_enter_critical(void);\nvoid rt_exit_critical(void);\nvoid rt_exit_critical_safe(rt_base_t critical_level);\nrt_uint16_t rt_critical_level(void);\n\n#ifdef RT_USING_HOOK\nvoid rt_scheduler_sethook(void (*hook)(rt_thread_t from, rt_thread_t to));\nvoid rt_scheduler_switch_sethook(void (*hook)(struct rt_thread *tid));\n#endif /* RT_USING_HOOK */\n\n#ifdef RT_USING_SMP\nvoid rt_secondary_cpu_entry(void);\nvoid rt_scheduler_ipi_handler(int vector, void *param);\n#endif /* RT_USING_SMP */\n\n/**@}*/\n\n/**\n * @addtogroup Signals\n * @{\n */\n#ifdef RT_USING_SIGNALS\nvoid rt_signal_mask(int signo);\nvoid rt_signal_unmask(int signo);\nrt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler);\nint rt_signal_wait(const rt_sigset_t *set, rt_siginfo_t *si, rt_int32_t timeout);\nint rt_system_signal_init(void);\n#endif /* RT_USING_SIGNALS */\n/**@}*/\n\n/**\n * @addtogroup MM\n * @{\n */\n\n/*\n * memory management interface\n */\n#ifdef RT_USING_MEMPOOL\n/*\n * memory pool interface\n */\nrt_err_t rt_mp_init(struct rt_mempool *mp,\n const char *name,\n void *start,\n rt_size_t size,\n rt_size_t block_size);\nrt_err_t rt_mp_detach(struct rt_mempool *mp);\n#ifdef RT_USING_HEAP\nrt_mp_t rt_mp_create(const char *name,\n rt_size_t block_count,\n rt_size_t block_size);\nrt_err_t rt_mp_delete(rt_mp_t mp);\n#endif /* RT_USING_HEAP */\nvoid *rt_mp_alloc(rt_mp_t mp, rt_int32_t time);\nvoid rt_mp_free(void *block);\n#ifdef RT_USING_HOOK\nvoid rt_mp_alloc_sethook(void (*hook)(struct rt_mempool *mp, void *block));\nvoid rt_mp_free_sethook(void (*hook)(struct rt_mempool *mp, void *block));\n#endif /* RT_USING_HOOK */\n\n#endif /* RT_USING_MEMPOOL */\n\n#ifdef RT_USING_HEAP\n/*\n * heap memory interface\n */\nvoid rt_system_heap_init(void *begin_addr, void *end_addr);\n\nvoid *rt_malloc(rt_size_t size);\nvoid rt_free(void *ptr);\nvoid *rt_realloc(void *ptr, rt_size_t newsize);\nvoid *rt_calloc(rt_size_t count, rt_size_t size);\nvoid *rt_malloc_align(rt_size_t size, rt_size_t align);\nvoid rt_free_align(void *ptr);\n\nvoid rt_memory_info(rt_size_t *total,\n rt_size_t *used,\n rt_size_t *max_used);\n\n#if defined(RT_USING_SLAB) && defined(RT_USING_SLAB_AS_HEAP)\nvoid *rt_page_alloc(rt_size_t npages);\nvoid rt_page_free(void *addr, rt_size_t npages);\n#endif /* defined(RT_USING_SLAB) && defined(RT_USING_SLAB_AS_HEAP) */\n\n#ifdef RT_USING_HOOK\nvoid rt_malloc_sethook(void (*hook)(void **ptr, rt_size_t size));\nvoid rt_realloc_set_entry_hook(void (*hook)(void **ptr, rt_size_t size));\nvoid rt_realloc_set_exit_hook(void (*hook)(void **ptr, rt_size_t size));\nvoid rt_free_sethook(void (*hook)(void **ptr));\n#endif /* RT_USING_HOOK */\n\n#endif /* RT_USING_HEAP */\n\n#ifdef RT_USING_SMALL_MEM\n/**\n * small memory object interface\n */\nrt_smem_t rt_smem_init(const char *name,\n void *begin_addr,\n rt_size_t size);\nrt_err_t rt_smem_detach(rt_smem_t m);\nvoid *rt_smem_alloc(rt_smem_t m, rt_size_t size);\nvoid *rt_smem_realloc(rt_smem_t m, void *rmem, rt_size_t newsize);\nvoid rt_smem_free(void *rmem);\n#endif /* RT_USING_SMALL_MEM */\n\n#ifdef RT_USING_MEMHEAP\n/**\n * memory heap object interface\n */\nrt_err_t rt_memheap_init(struct rt_memheap *memheap,\n const char *name,\n void *start_addr,\n rt_size_t size);\nrt_err_t rt_memheap_detach(struct rt_memheap *heap);\nvoid *rt_memheap_alloc(struct rt_memheap *heap, rt_size_t size);\nvoid *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize);\nvoid rt_memheap_free(void *ptr);\nvoid rt_memheap_info(struct rt_memheap *heap,\n rt_size_t *total,\n rt_size_t *used,\n rt_size_t *max_used);\n#endif /* RT_USING_MEMHEAP */\n\n#ifdef RT_USING_MEMHEAP_AS_HEAP\n/**\n * memory heap as heap\n */\nvoid *_memheap_alloc(struct rt_memheap *heap, rt_size_t size);\nvoid _memheap_free(void *rmem);\nvoid *_memheap_realloc(struct rt_memheap *heap, void *rmem, rt_size_t newsize);\n#endif\n\n#ifdef RT_USING_SLAB\n/**\n * slab object interface\n */\nrt_slab_t rt_slab_init(const char *name, void *begin_addr, rt_size_t size);\nrt_err_t rt_slab_detach(rt_slab_t m);\nvoid *rt_slab_page_alloc(rt_slab_t m, rt_size_t npages);\nvoid rt_slab_page_free(rt_slab_t m, void *addr, rt_size_t npages);\nvoid *rt_slab_alloc(rt_slab_t m, rt_size_t size);\nvoid *rt_slab_realloc(rt_slab_t m, void *ptr, rt_size_t size);\nvoid rt_slab_free(rt_slab_t m, void *ptr);\n#endif /* RT_USING_SLAB */\n\n/**@}*/\n\n/**\n * @addtogroup IPC\n * @{\n */\n\n/**\n * Suspend list - A basic building block for IPC primitives which interacts with\n * scheduler directly. Its API is similar to a FIFO list.\n *\n * Note: don't use in application codes directly\n */\nvoid rt_susp_list_print(rt_list_t *list);\n/* reserve thread error while resuming it */\n#define RT_THREAD_RESUME_RES_THR_ERR (-1)\nstruct rt_thread *rt_susp_list_dequeue(rt_list_t *susp_list, rt_err_t thread_error);\nrt_err_t rt_susp_list_resume_all(rt_list_t *susp_list, rt_err_t thread_error);\nrt_err_t rt_susp_list_resume_all_irq(rt_list_t *susp_list,\n rt_err_t thread_error,\n struct rt_spinlock *lock);\n\n/* suspend and enqueue */\nrt_err_t rt_thread_suspend_to_list(rt_thread_t thread, rt_list_t *susp_list, int ipc_flags, int suspend_flag);\n/* only for a suspended thread, and caller must hold the scheduler lock */\nrt_err_t rt_susp_list_enqueue(rt_list_t *susp_list, rt_thread_t thread, int ipc_flags);\n\n#ifdef RT_USING_SEMAPHORE\n/*\n * semaphore interface\n */\nrt_err_t rt_sem_init(rt_sem_t sem,\n const char *name,\n rt_uint32_t value,\n rt_uint8_t flag);\nrt_err_t rt_sem_detach(rt_sem_t sem);\n#ifdef RT_USING_HEAP\nrt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag);\nrt_err_t rt_sem_delete(rt_sem_t sem);\n#endif /* RT_USING_HEAP */\n\nrt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout);\nrt_err_t rt_sem_take_interruptible(rt_sem_t sem, rt_int32_t timeout);\nrt_err_t rt_sem_take_killable(rt_sem_t sem, rt_int32_t timeout);\nrt_err_t rt_sem_trytake(rt_sem_t sem);\nrt_err_t rt_sem_release(rt_sem_t sem);\nrt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg);\n#endif /* RT_USING_SEMAPHORE */\n\n#ifdef RT_USING_MUTEX\n/*\n * mutex interface\n */\nrt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag);\nrt_err_t rt_mutex_detach(rt_mutex_t mutex);\n#ifdef RT_USING_HEAP\nrt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag);\nrt_err_t rt_mutex_delete(rt_mutex_t mutex);\n#endif /* RT_USING_HEAP */\nvoid rt_mutex_drop_thread(rt_mutex_t mutex, rt_thread_t thread);\nrt_uint8_t rt_mutex_setprioceiling(rt_mutex_t mutex, rt_uint8_t priority);\nrt_uint8_t rt_mutex_getprioceiling(rt_mutex_t mutex);\n\nrt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout);\nrt_err_t rt_mutex_trytake(rt_mutex_t mutex);\nrt_err_t rt_mutex_take_interruptible(rt_mutex_t mutex, rt_int32_t time);\nrt_err_t rt_mutex_take_killable(rt_mutex_t mutex, rt_int32_t time);\nrt_err_t rt_mutex_release(rt_mutex_t mutex);\nrt_err_t rt_mutex_control(rt_mutex_t mutex, int cmd, void *arg);\n\nrt_inline rt_thread_t rt_mutex_get_owner(rt_mutex_t mutex)\n{\n return mutex->owner;\n}\nrt_inline rt_ubase_t rt_mutex_get_hold(rt_mutex_t mutex)\n{\n return mutex->hold;\n}\n\n#endif /* RT_USING_MUTEX */\n\n#ifdef RT_USING_EVENT\n/*\n * event interface\n */\nrt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag);\nrt_err_t rt_event_detach(rt_event_t event);\n#ifdef RT_USING_HEAP\nrt_event_t rt_event_create(const char *name, rt_uint8_t flag);\nrt_err_t rt_event_delete(rt_event_t event);\n#endif /* RT_USING_HEAP */\n\nrt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);\nrt_err_t rt_event_recv(rt_event_t event,\n rt_uint32_t set,\n rt_uint8_t opt,\n rt_int32_t timeout,\n rt_uint32_t *recved);\nrt_err_t rt_event_recv_interruptible(rt_event_t event,\n rt_uint32_t set,\n rt_uint8_t opt,\n rt_int32_t timeout,\n rt_uint32_t *recved);\nrt_err_t rt_event_recv_killable(rt_event_t event,\n rt_uint32_t set,\n rt_uint8_t opt,\n rt_int32_t timeout,\n rt_uint32_t *recved);\nrt_err_t rt_event_control(rt_event_t event, int cmd, void *arg);\n#endif /* RT_USING_EVENT */\n\n#ifdef RT_USING_MAILBOX\n/*\n * mailbox interface\n */\nrt_err_t rt_mb_init(rt_mailbox_t mb,\n const char *name,\n void *msgpool,\n rt_size_t size,\n rt_uint8_t flag);\nrt_err_t rt_mb_detach(rt_mailbox_t mb);\n#ifdef RT_USING_HEAP\nrt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag);\nrt_err_t rt_mb_delete(rt_mailbox_t mb);\n#endif /* RT_USING_HEAP */\n\nrt_err_t rt_mb_send(rt_mailbox_t mb, rt_ubase_t value);\nrt_err_t rt_mb_send_interruptible(rt_mailbox_t mb, rt_ubase_t value);\nrt_err_t rt_mb_send_killable(rt_mailbox_t mb, rt_ubase_t value);\nrt_err_t rt_mb_send_wait(rt_mailbox_t mb,\n rt_ubase_t value,\n rt_int32_t timeout);\nrt_err_t rt_mb_send_wait_interruptible(rt_mailbox_t mb,\n rt_ubase_t value,\n rt_int32_t timeout);\nrt_err_t rt_mb_send_wait_killable(rt_mailbox_t mb,\n rt_ubase_t value,\n rt_int32_t timeout);\nrt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value);\nrt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout);\nrt_err_t rt_mb_recv_interruptible(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout);\nrt_err_t rt_mb_recv_killable(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout);\nrt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg);\n#endif /* RT_USING_MAILBOX */\n\n#ifdef RT_USING_MESSAGEQUEUE\n\nstruct rt_mq_message\n{\n struct rt_mq_message *next;\n rt_ssize_t length;\n#ifdef RT_USING_MESSAGEQUEUE_PRIORITY\n rt_int32_t prio;\n#endif /* RT_USING_MESSAGEQUEUE_PRIORITY */\n};\n\n#define RT_MQ_BUF_SIZE(msg_size, max_msgs) \\\n((RT_ALIGN((msg_size), RT_ALIGN_SIZE) + sizeof(struct rt_mq_message)) * (max_msgs))\n\n/*\n * message queue interface\n */\nrt_err_t rt_mq_init(rt_mq_t mq,\n const char *name,\n void *msgpool,\n rt_size_t msg_size,\n rt_size_t pool_size,\n rt_uint8_t flag);\nrt_err_t rt_mq_detach(rt_mq_t mq);\n#ifdef RT_USING_HEAP\nrt_mq_t rt_mq_create(const char *name,\n rt_size_t msg_size,\n rt_size_t max_msgs,\n rt_uint8_t flag);\nrt_err_t rt_mq_delete(rt_mq_t mq);\n#endif /* RT_USING_HEAP */\n\nrt_err_t rt_mq_send(rt_mq_t mq, const void *buffer, rt_size_t size);\nrt_err_t rt_mq_send_interruptible(rt_mq_t mq, const void *buffer, rt_size_t size);\nrt_err_t rt_mq_send_killable(rt_mq_t mq, const void *buffer, rt_size_t size);\nrt_err_t rt_mq_send_wait(rt_mq_t mq,\n const void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_err_t rt_mq_send_wait_interruptible(rt_mq_t mq,\n const void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_err_t rt_mq_send_wait_killable(rt_mq_t mq,\n const void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size);\nrt_ssize_t rt_mq_recv(rt_mq_t mq,\n void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_ssize_t rt_mq_recv_interruptible(rt_mq_t mq,\n void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_ssize_t rt_mq_recv_killable(rt_mq_t mq,\n void *buffer,\n rt_size_t size,\n rt_int32_t timeout);\nrt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg);\n\n#ifdef RT_USING_MESSAGEQUEUE_PRIORITY\nrt_err_t rt_mq_send_wait_prio(rt_mq_t mq,\n const void *buffer,\n rt_size_t size,\n rt_int32_t prio,\n rt_int32_t timeout,\n int suspend_flag);\nrt_ssize_t rt_mq_recv_prio(rt_mq_t mq,\n void *buffer,\n rt_size_t size,\n rt_int32_t *prio,\n rt_int32_t timeout,\n int suspend_flag);\n#endif /* RT_USING_MESSAGEQUEUE_PRIORITY */\n#endif /* RT_USING_MESSAGEQUEUE */\n\n/* defunct */\nvoid rt_thread_defunct_enqueue(rt_thread_t thread);\nrt_thread_t rt_thread_defunct_dequeue(void);\n\n/*\n * spinlock\n */\nstruct rt_spinlock;\n#ifdef RT_USING_SMP\n\nvoid rt_spin_lock_init(struct rt_spinlock *lock);\nvoid rt_spin_lock(struct rt_spinlock *lock);\nvoid rt_spin_unlock(struct rt_spinlock *lock);\nrt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock);\nvoid rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t level);\n#else\n\nrt_inline void rt_spin_lock_init(struct rt_spinlock *lock)\n{\n RT_UNUSED(lock);\n}\nrt_inline void rt_spin_lock(struct rt_spinlock *lock)\n{\n RT_UNUSED(lock);\n rt_enter_critical();\n}\nrt_inline void rt_spin_unlock(struct rt_spinlock *lock)\n{\n RT_UNUSED(lock);\n rt_exit_critical();\n}\nrt_inline rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock)\n{\n rt_base_t level;\n RT_UNUSED(lock);\n level = rt_hw_interrupt_disable();\n return level;\n}\nrt_inline void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t level)\n{\n RT_UNUSED(lock);\n rt_hw_interrupt_enable(level);\n}\n\n#endif /* RT_USING_SMP */\n\n/**@}*/\n\n#ifdef RT_USING_DEVICE\n/**\n * @addtogroup Device\n * @{\n */\n\n/*\n * device (I/O) system interface\n */\nrt_device_t rt_device_find(const char *name);\n\nrt_err_t rt_device_register(rt_device_t dev,\n const char *name,\n rt_uint16_t flags);\nrt_err_t rt_device_unregister(rt_device_t dev);\n\n#ifdef RT_USING_HEAP\nrt_device_t rt_device_create(int type, int attach_size);\nvoid rt_device_destroy(rt_device_t device);\n#endif /* RT_USING_HEAP */\n\nrt_err_t\nrt_device_set_rx_indicate(rt_device_t dev,\n rt_err_t (*rx_ind)(rt_device_t dev, rt_size_t size));\nrt_err_t\nrt_device_set_tx_complete(rt_device_t dev,\n rt_err_t (*tx_done)(rt_device_t dev, void *buffer));\n\nrt_err_t rt_device_init (rt_device_t dev);\nrt_err_t rt_device_open (rt_device_t dev, rt_uint16_t oflag);\nrt_err_t rt_device_close(rt_device_t dev);\nrt_ssize_t rt_device_read(rt_device_t dev,\n rt_off_t pos,\n void *buffer,\n rt_size_t size);\nrt_ssize_t rt_device_write(rt_device_t dev,\n rt_off_t pos,\n const void *buffer,\n rt_size_t size);\nrt_err_t rt_device_control(rt_device_t dev, int cmd, void *arg);\n\n/**@}*/\n#endif /* RT_USING_DEVICE */\n\n/*\n * interrupt service\n */\n\n/*\n * rt_interrupt_enter and rt_interrupt_leave only can be called by BSP\n */\nvoid rt_interrupt_enter(void);\nvoid rt_interrupt_leave(void);\n\n#ifdef RT_USING_SMP\n\n/*\n * smp cpus lock service\n */\n\nrt_base_t rt_cpus_lock(void);\nvoid rt_cpus_unlock(rt_base_t level);\n\nstruct rt_cpu *rt_cpu_self(void);\nstruct rt_cpu *rt_cpu_index(int index);\n\nvoid rt_cpus_lock_status_restore(struct rt_thread *thread);\n\n#endif /* RT_USING_SMP */\n\n/*\n * the number of nested interrupts.\n */\nrt_uint8_t rt_interrupt_get_nest(void);\n\n#ifdef RT_USING_HOOK\nvoid rt_interrupt_enter_sethook(void (*hook)(void));\nvoid rt_interrupt_leave_sethook(void (*hook)(void));\n#endif /* RT_USING_HOOK */\n\n#ifdef RT_USING_COMPONENTS_INIT\nvoid rt_components_init(void);\nvoid rt_components_board_init(void);\n#endif /* RT_USING_COMPONENTS_INIT */\n\n/**\n * @addtogroup KernelService\n * @{\n */\n\n/*\n * general kernel service\n */\n#ifndef RT_USING_CONSOLE\n#define rt_kprintf(...)\n#define rt_kputs(str)\n#else\nint rt_kprintf(const char *fmt, ...);\nvoid rt_kputs(const char *str);\n#endif /* RT_USING_CONSOLE */\n\nrt_err_t rt_backtrace(void);\nrt_err_t rt_backtrace_thread(rt_thread_t thread);\nrt_err_t rt_backtrace_frame(struct rt_hw_backtrace_frame *frame);\n\n#if defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE)\nrt_device_t rt_console_set_device(const char *name);\nrt_device_t rt_console_get_device(void);\n#ifdef RT_USING_THREADSAFE_PRINTF\n rt_thread_t rt_console_current_user(void);\n#else\n rt_inline void *rt_console_current_user(void) { return RT_NULL; }\n#endif /* RT_USING_THREADSAFE_PRINTF */\n#endif /* defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE) */\n\nrt_err_t rt_get_errno(void);\nvoid rt_set_errno(rt_err_t no);\nint *_rt_errno(void);\nconst char *rt_strerror(rt_err_t error);\n#if !defined(RT_USING_NEWLIBC) && !defined(_WIN32)\n#ifndef errno\n#define errno *_rt_errno()\n#endif\n#endif /* !defined(RT_USING_NEWLIBC) && !defined(_WIN32) */\n\nint __rt_ffs(int value);\n\nvoid rt_show_version(void);\n\n#ifdef RT_USING_DEBUG\nextern void (*rt_assert_hook)(const char *ex, const char *func, rt_size_t line);\nvoid rt_assert_set_hook(void (*hook)(const char *ex, const char *func, rt_size_t line));\nvoid rt_assert_handler(const char *ex, const char *func, rt_size_t line);\n\n#define RT_ASSERT(EX) \\\nif (!(EX)) \\\n{ \\\n rt_assert_handler(#EX, __FUNCTION__, __LINE__); \\\n}\n#else\n#define RT_ASSERT(EX)\n#endif /* RT_USING_DEBUG */\n\n#ifdef RT_DEBUGING_CONTEXT\n/* Macro to check current context */\n#define RT_DEBUG_NOT_IN_INTERRUPT \\\ndo \\\n{ \\\n if (rt_interrupt_get_nest() != 0) \\\n { \\\n rt_kprintf(\"Function[%s] shall not be used in ISR\\n\", __FUNCTION__); \\\n RT_ASSERT(0) \\\n } \\\n} \\\nwhile (0)\n\n/* \"In thread context\" means:\n * 1) the scheduler has been started\n * 2) not in interrupt context.\n */\n#define RT_DEBUG_IN_THREAD_CONTEXT \\\ndo \\\n{ \\\n if (rt_thread_self() == RT_NULL) \\\n { \\\n rt_kprintf(\"Function[%s] shall not be used before scheduler start\\n\", \\\n __FUNCTION__); \\\n RT_ASSERT(0) \\\n } \\\n RT_DEBUG_NOT_IN_INTERRUPT; \\\n} \\\nwhile (0)\n\n/* \"scheduler available\" means:\n * 1) the scheduler has been started.\n * 2) not in interrupt context.\n * 3) scheduler is not locked.\n * 4) interrupt is not disabled.\n */\n#define RT_DEBUG_SCHEDULER_AVAILABLE(need_check) \\\ndo \\\n{ \\\n if (need_check) \\\n { \\\n rt_bool_t interrupt_disabled; \\\n interrupt_disabled = rt_hw_interrupt_is_disabled(); \\\n if (rt_critical_level() != 0) \\\n { \\\n rt_kprintf(\"Function[%s]: scheduler is not available\\n\", \\\n __FUNCTION__); \\\n RT_ASSERT(0) \\\n } \\\n if (interrupt_disabled == RT_TRUE) \\\n { \\\n rt_kprintf(\"Function[%s]: interrupt is disabled\\n\", \\\n __FUNCTION__); \\\n RT_ASSERT(0) \\\n } \\\n RT_DEBUG_IN_THREAD_CONTEXT; \\\n } \\\n} \\\nwhile (0)\n#else\n#define RT_DEBUG_NOT_IN_INTERRUPT\n#define RT_DEBUG_IN_THREAD_CONTEXT\n#define RT_DEBUG_SCHEDULER_AVAILABLE(need_check)\n#endif /* RT_DEBUGING_CONTEXT */\n\nrt_inline rt_bool_t rt_in_thread_context(void)\n{\n return rt_thread_self() != RT_NULL && rt_interrupt_get_nest() == 0;\n}\n\nrt_inline rt_bool_t rt_scheduler_is_available(void)\n{\n return !rt_hw_interrupt_is_disabled() && rt_critical_level() == 0 && rt_in_thread_context();\n}\n\n/**@}*/\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* __RT_THREAD_H__ */\n", "include/rtdbg.h": "/*\n * Copyright (c) 2006-2021, RT-Thread Development Team\n *\n * SPDX-License-Identifier: Apache-2.0\n *\n * Change Logs:\n * Date Author Notes\n * 2016-11-12 Bernard The first version\n * 2018-05-25 armink Add simple API, such as LOG_D, LOG_E\n */\n\n/*\n * The macro definitions for debug\n *\n * These macros are defined in static. If you want to use debug macro, you can\n * use as following code:\n *\n * In your C/C++ file, enable/disable DEBUG_ENABLE macro, and then include this\n * header file.\n *\n * #define DBG_TAG \"MOD_TAG\"\n * #define DBG_LVL DBG_INFO\n * #include <rtdbg.h> // must after of DBG_LVL, DBG_TAG or other options\n *\n * Then in your C/C++ file, you can use LOG_X macro to print out logs:\n * LOG_D(\"this is a debug log!\");\n * LOG_E(\"this is a error log!\");\n */\n\n#ifndef RT_DBG_H__\n#define RT_DBG_H__\n\n#include <rtconfig.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* the debug log will force enable when RT_USING_DEBUG macro is defined */\n#if defined(RT_USING_DEBUG) && !defined(DBG_ENABLE)\n#define DBG_ENABLE\n#endif\n\n/* it will force output color log when RT_DEBUGING_COLOR macro is defined */\n#if defined(RT_DEBUGING_COLOR) && !defined(DBG_COLOR)\n#define DBG_COLOR\n#endif\n\n/* for dlog */\n#ifdef PKG_USING_DLOG\n#include <dlog.h>\n#else\n#define DLOG(...)\n#endif\n\n#if defined(RT_USING_ULOG)\n/* using ulog compatible with rtdbg */\n#include <ulog.h>\n#else\n\n/* DEBUG level */\n#define DBG_ERROR 0\n#define DBG_WARNING 1\n#define DBG_INFO 2\n#define DBG_LOG 3\n\n#ifdef DBG_TAG\n#ifndef DBG_SECTION_NAME\n#define DBG_SECTION_NAME DBG_TAG\n#endif\n#else\n/* compatible with old version */\n#ifndef DBG_SECTION_NAME\n#define DBG_SECTION_NAME \"DBG\"\n#endif\n#endif /* DBG_TAG */\n\n#ifdef DBG_ENABLE\n\n#ifdef DBG_LVL\n#ifndef DBG_LEVEL\n#define DBG_LEVEL DBG_LVL\n#endif\n#else\n/* compatible with old version */\n#ifndef DBG_LEVEL\n#define DBG_LEVEL DBG_WARNING\n#endif\n#endif /* DBG_LVL */\n\n/*\n * The color for terminal (foreground)\n * BLACK 30\n * RED 31\n * GREEN 32\n * YELLOW 33\n * BLUE 34\n * PURPLE 35\n * CYAN 36\n * WHITE 37\n */\n#ifdef DBG_COLOR\n#define _DBG_COLOR(n) rt_kprintf(\"\\033[\"#n\"m\")\n#define _DBG_LOG_HDR(lvl_name, color_n) \\\n rt_kprintf(\"\\033[\"#color_n\"m[\" lvl_name \"/\" DBG_SECTION_NAME \"] \")\n#define _DBG_LOG_X_END \\\n rt_kprintf(\"\\033[0m\\n\")\n#else\n#define _DBG_COLOR(n)\n#define _DBG_LOG_HDR(lvl_name, color_n) \\\n rt_kprintf(\"[\" lvl_name \"/\" DBG_SECTION_NAME \"] \")\n#define _DBG_LOG_X_END \\\n rt_kprintf(\"\\n\")\n#endif /* DBG_COLOR */\n\n/*\n * static debug routine\n * NOTE: This is a NOT RECOMMENDED API. Please using LOG_X API.\n * It will be DISCARDED later. Because it will take up more resources.\n */\n#define dbg_log(level, fmt, ...) \\\n if ((level) <= DBG_LEVEL) \\\n { \\\n switch(level) \\\n { \\\n case DBG_ERROR: _DBG_LOG_HDR(\"E\", 31); break; \\\n case DBG_WARNING: _DBG_LOG_HDR(\"W\", 33); break; \\\n case DBG_INFO: _DBG_LOG_HDR(\"I\", 32); break; \\\n case DBG_LOG: _DBG_LOG_HDR(\"D\", 0); break; \\\n default: break; \\\n } \\\n rt_kprintf(fmt, ##__VA_ARGS__); \\\n _DBG_COLOR(0); \\\n }\n\n#define dbg_here \\\n if ((DBG_LEVEL) <= DBG_LOG){ \\\n rt_kprintf(DBG_SECTION_NAME \" Here %s:%d\\n\", \\\n __FUNCTION__, __LINE__); \\\n }\n\n#define dbg_log_line(lvl, color_n, fmt, ...) \\\n do \\\n { \\\n _DBG_LOG_HDR(lvl, color_n); \\\n rt_kprintf(fmt, ##__VA_ARGS__); \\\n _DBG_LOG_X_END; \\\n } \\\n while (0)\n\n#define dbg_raw(...) rt_kprintf(__VA_ARGS__);\n\n#else\n#define dbg_log(level, fmt, ...)\n#define dbg_here\n#define dbg_enter\n#define dbg_exit\n#define dbg_log_line(lvl, color_n, fmt, ...)\n#define dbg_raw(...)\n#endif /* DBG_ENABLE */\n\n#if (DBG_LEVEL >= DBG_LOG)\n#define LOG_D(fmt, ...) dbg_log_line(\"D\", 0, fmt, ##__VA_ARGS__)\n#else\n#define LOG_D(...)\n#endif\n\n#if (DBG_LEVEL >= DBG_INFO)\n#define LOG_I(fmt, ...) dbg_log_line(\"I\", 32, fmt, ##__VA_ARGS__)\n#else\n#define LOG_I(...)\n#endif\n\n#if (DBG_LEVEL >= DBG_WARNING)\n#define LOG_W(fmt, ...) dbg_log_line(\"W\", 33, fmt, ##__VA_ARGS__)\n#else\n#define LOG_W(...)\n#endif\n\n#if (DBG_LEVEL >= DBG_ERROR)\n#define LOG_E(fmt, ...) dbg_log_line(\"E\", 31, fmt, ##__VA_ARGS__)\n#else\n#define LOG_E(...)\n#endif\n\n#define LOG_RAW(...) dbg_raw(__VA_ARGS__)\n\n#define LOG_HEX(name, width, buf, size)\n\n#endif /* defined(RT_USING_ULOG) && define(DBG_ENABLE) */\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif /* RT_DBG_H__ */\n"} |