Batch 28 commit ca63702 gave RT-Thread mutex priority ceilings (1 of 3 passed), LVGL repeat cadence and RT-Thread soft-timer wakeup (0 of 3) as HARD. 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>
146 lines
6.3 KiB
C
146 lines
6.3 KiB
C
#define _XOPEN_SOURCE 700
|
|
#include <ucontext.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <rthw.h>
|
|
#include "controlled.h"
|
|
|
|
static struct rt_cpu cpu;
|
|
static struct rt_thread application;
|
|
static rt_thread_t worker;
|
|
static rt_tick_t now;
|
|
static ucontext_t driver_context, worker_context;
|
|
static unsigned char execution_stack[131072];
|
|
static rt_list_t ready;
|
|
static int in_worker, injecting, initialized, duplicate_ready, operations, interleavings;
|
|
static int capture;
|
|
static struct rt_spinlock *captured, *after_lock, *before_lock;
|
|
static void (*after_fn)(void *), (*before_fn)(void *);
|
|
static void *after_arg, *before_arg;
|
|
static rt_base_t irq;
|
|
|
|
static void budget(void) { if (++operations > 2000000) { fputs("port operation budget\n", stderr); exit(7); } }
|
|
static void interleave(void (*fn)(void *), void *arg)
|
|
{
|
|
rt_thread_t previous = cpu.current_thread;
|
|
int previous_in = in_worker;
|
|
cpu.current_thread = &application;
|
|
in_worker = 0; injecting = 1; interleavings++;
|
|
fn(arg);
|
|
injecting = 0; in_worker = previous_in; cpu.current_thread = previous;
|
|
}
|
|
struct rt_cpu *rt_cpu_self(void) { return &cpu; }
|
|
int rt_hw_cpu_id(void) { return 0; }
|
|
rt_base_t rt_hw_local_irq_disable(void) { rt_base_t saved = irq; irq = 1; return saved; }
|
|
void rt_hw_local_irq_enable(rt_base_t saved) { irq = saved; }
|
|
rt_base_t rt_cpus_lock(void) { return rt_hw_local_irq_disable(); }
|
|
void rt_cpus_unlock(rt_base_t saved) { rt_hw_local_irq_enable(saved); }
|
|
rt_bool_t rt_hw_interrupt_is_disabled(void) { return irq != 0; }
|
|
void rt_spin_lock_init(struct rt_spinlock *lock) { lock->lock = 0; }
|
|
rt_base_t rt_spin_lock_irqsave(struct rt_spinlock *lock)
|
|
{
|
|
budget();
|
|
if (capture) { capture = 0; captured = lock; }
|
|
if (!injecting && before_fn && lock == before_lock) {
|
|
void (*fn)(void *) = before_fn; void *arg = before_arg; before_fn = NULL;
|
|
interleave(fn, arg);
|
|
}
|
|
lock->lock++;
|
|
return rt_hw_local_irq_disable();
|
|
}
|
|
void rt_spin_unlock_irqrestore(struct rt_spinlock *lock, rt_base_t saved)
|
|
{
|
|
budget();
|
|
lock->lock--;
|
|
rt_hw_local_irq_enable(saved);
|
|
if (!injecting && after_fn && lock == after_lock) {
|
|
void (*fn)(void *) = after_fn; void *arg = after_arg; after_fn = NULL;
|
|
interleave(fn, arg);
|
|
}
|
|
}
|
|
void rt_spin_lock(struct rt_spinlock *lock) { (void)rt_spin_lock_irqsave(lock); }
|
|
void rt_spin_unlock(struct rt_spinlock *lock) { rt_spin_unlock_irqrestore(lock, 0); }
|
|
rt_tick_t rt_tick_get(void) { budget(); return now; }
|
|
void rt_object_init(struct rt_object *object, enum rt_object_class_type type, const char *name)
|
|
{
|
|
memset(object, 0, sizeof(*object));
|
|
strncpy(object->name, name, RT_NAME_MAX - 1);
|
|
object->type = type | RT_Object_Class_Static;
|
|
rt_list_init(&object->list);
|
|
}
|
|
rt_uint8_t rt_object_get_type(rt_object_t object) { return object->type & ~RT_Object_Class_Static; }
|
|
rt_bool_t rt_object_is_systemobject(rt_object_t object) { return !!(object->type & RT_Object_Class_Static); }
|
|
void rt_object_detach(rt_object_t object) { rt_list_remove(&object->list); }
|
|
rt_uint8_t *rt_hw_stack_init(void *entry, void *parameter, rt_uint8_t *stack, void *exit_fn)
|
|
{ (void)entry; (void)parameter; (void)exit_fn; return stack; }
|
|
void rt_thread_defunct_enqueue(rt_thread_t thread) { (void)thread; }
|
|
void rt_schedule_remove_thread(rt_thread_t thread) { rt_list_remove(&thread->tlist_schedule); }
|
|
void rt_schedule_insert_thread(rt_thread_t thread)
|
|
{
|
|
if (!rt_list_isempty(&thread->tlist_schedule)) duplicate_ready++;
|
|
else rt_list_insert_before(&ready, &thread->tlist_schedule);
|
|
thread->stat = (thread->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_READY;
|
|
if (strcmp(thread->parent.name, "timer") == 0) worker = thread;
|
|
}
|
|
void rt_schedule(void)
|
|
{
|
|
budget();
|
|
if (in_worker && ((worker->stat & RT_THREAD_SUSPEND_MASK) == RT_THREAD_SUSPEND_MASK ||
|
|
(worker->stat & RT_THREAD_STAT_MASK) == RT_THREAD_CLOSE))
|
|
swapcontext(&worker_context, &driver_context);
|
|
else if (in_worker && (worker->stat & RT_THREAD_STAT_MASK) == RT_THREAD_READY) {
|
|
rt_list_remove(&worker->tlist_schedule);
|
|
worker->stat = (worker->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_RUNNING;
|
|
}
|
|
}
|
|
static void worker_entry(void)
|
|
{
|
|
((void (*)(void *))worker->entry)(worker->parameter);
|
|
worker->stat = RT_THREAD_CLOSE;
|
|
swapcontext(&worker_context, &driver_context);
|
|
}
|
|
void port_init(rt_tick_t tick)
|
|
{
|
|
now = tick; rt_list_init(&ready);
|
|
rt_object_init(&application.parent, RT_Object_Class_Thread, "application");
|
|
application.stat = RT_THREAD_RUNNING; cpu.current_thread = &application;
|
|
rt_system_timer_init(); rt_system_timer_thread_init();
|
|
}
|
|
void port_pump(void)
|
|
{
|
|
if (!worker || (worker->stat & RT_THREAD_STAT_MASK) != RT_THREAD_READY) return;
|
|
if (!initialized) {
|
|
initialized = 1; getcontext(&worker_context);
|
|
worker_context.uc_stack.ss_sp = execution_stack;
|
|
worker_context.uc_stack.ss_size = sizeof(execution_stack);
|
|
worker_context.uc_link = &driver_context;
|
|
makecontext(&worker_context, worker_entry, 0);
|
|
}
|
|
rt_list_remove(&worker->tlist_schedule);
|
|
worker->stat = (worker->stat & ~RT_THREAD_STAT_MASK) | RT_THREAD_RUNNING;
|
|
cpu.current_thread = worker; in_worker = 1;
|
|
swapcontext(&driver_context, &worker_context);
|
|
in_worker = 0; cpu.current_thread = &application;
|
|
}
|
|
void port_advance(rt_tick_t tick) { now = tick; rt_timer_check(); port_pump(); }
|
|
rt_thread_t port_worker(void) { return worker; }
|
|
void port_capture_lock(void) { captured = NULL; capture = 1; }
|
|
struct rt_spinlock *port_captured_lock(void) { return captured; }
|
|
void port_after_unlock(struct rt_spinlock *lock, void (*fn)(void *), void *arg)
|
|
{ after_lock = lock; after_fn = fn; after_arg = arg; }
|
|
void port_before_lock(struct rt_spinlock *lock, void (*fn)(void *), void *arg)
|
|
{ before_lock = lock; before_fn = fn; before_arg = arg; }
|
|
int port_duplicate_ready(void) { return duplicate_ready; }
|
|
int port_ready_count(rt_thread_t thread)
|
|
{
|
|
int count = 0; rt_list_t *p;
|
|
for (p = ready.next; p != &ready && count < 100; p = p->next)
|
|
if (p == &thread->tlist_schedule) count++;
|
|
return count;
|
|
}
|
|
int port_interleavings(void) { return interleavings; }
|
|
void 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(8); }
|
|
void *rt_memset(void *s, int c, rt_ubase_t count) { return memset(s, c, count); }
|