rt 0.17.0

A real-time operating system capable of full preemption
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

#include <rt/sem.h>

#include <rt/interrupt.h>
#include <rt/task.h>
#include <rt/trace.h>

static int new_value(int value, int n, int max)
{
    if (value <= max - n)
    {
        return value + n;
    }
    return max;
}

static void sem_post_pend(struct rt_sem *sem, int n)
{
    /* If the semaphore's post record is already pending, don't attempt to
     * use it again. The interrupt that is using it will still cause the
     * post to occur, so no posts are missed in this case. Instead, just
     * add to the semaphore value directly. The system call will run
     * after this increment has taken effect. */
    if (rt_atomic_flag_test_and_set(&sem->post_record.pending,
                                    RT_ATOMIC_ACQUIRE))
    {
        rt_sem_add_n(sem, n);
        return;
    }
    sem->post_record.args.sem_post.n = n;
    rt_syscall_push(&sem->post_record);
    rt_syscall_pend();
}

static bool sem_post_fast(struct rt_sem *sem, int n)
{
    int value = rt_atomic_load(&sem->value, RT_ATOMIC_RELAXED);
    int new;
    do
    {
        /* If the value is negative, then the post needs to happen in a
         * system call because there are waiters. Adding to the semaphore
         * value directly when there are waiters can result in priority
         * inversion if a context switch occurs before wakes are resolved
         * but after the value is incremented, and the semaphore is
         * decremented on the fast path by another task that is lower
         * priority than a previous waiter. */
        if (value < 0)
        {
            return false;
        }
        new = new_value(value, n, sem->max_value);
    } while (!rt_atomic_compare_exchange_weak(&sem->value, &value, new,
                                              RT_ATOMIC_RELEASE,
                                              RT_ATOMIC_RELAXED));
    rt_trace_sem_update(sem, value, new);
    return true;
}

void rt_sem_post_n(struct rt_sem *sem, int n)
{
    if (!sem_post_fast(sem, n))
    {
        /* In an interrupt, we need to use the post system call record
         * attached to the semaphore because the interrupt will return
         * before system calls are handled and the stack frame won't be live
         * anymore. */
        if (rt_interrupt_is_active())
        {
            sem_post_pend(sem, n);
        }
        else
        {
            rt_syscall_sem_post(sem, n);
        }
    }
}

void rt_sem_post_n_from_task(struct rt_sem *sem, int n)
{
    if (!sem_post_fast(sem, n))
    {
        rt_syscall_sem_post(sem, n);
    }
}

void rt_sem_post_n_from_interrupt(struct rt_sem *sem, int n)
{
    if (!sem_post_fast(sem, n))
    {
        sem_post_pend(sem, n);
    }
}

void rt_sem_post(struct rt_sem *sem)
{
    rt_sem_post_n(sem, 1);
}

void rt_sem_post_from_task(struct rt_sem *sem)
{
    rt_sem_post_n_from_task(sem, 1);
}

void rt_sem_post_from_interrupt(struct rt_sem *sem)
{
    rt_sem_post_n_from_interrupt(sem, 1);
}

bool rt_sem_trywait(struct rt_sem *sem)
{
    int value = rt_atomic_load(&sem->value, RT_ATOMIC_RELAXED);
    do
    {
        if (value <= 0)
        {
            return false;
        }
    } while (!rt_atomic_compare_exchange_weak(&sem->value, &value, value - 1,
                                              RT_ATOMIC_ACQUIRE,
                                              RT_ATOMIC_RELAXED));
    rt_trace_sem_update(sem, value, value - 1);
    return true;
}

void rt_sem_wait(struct rt_sem *sem)
{
    const int value = rt_atomic_fetch_sub(&sem->value, 1, RT_ATOMIC_ACQUIRE);
    rt_trace_sem_update(sem, value, value - 1);
    if (value > 0)
    {
        return;
    }
    rt_syscall_sem_wait(sem);
}

bool rt_sem_timedwait(struct rt_sem *sem, unsigned long ticks)
{
    if (ticks == 0)
    {
        return rt_sem_trywait(sem);
    }
    const int value = rt_atomic_fetch_sub(&sem->value, 1, RT_ATOMIC_ACQUIRE);
    rt_trace_sem_update(sem, value, value - 1);
    if (value > 0)
    {
        return true;
    }
    return rt_syscall_sem_timedwait(sem, ticks);
}

void rt_sem_add_n(struct rt_sem *sem, int n)
{
    int value = rt_atomic_load(&sem->value, RT_ATOMIC_RELAXED);
    int new;
    do
    {
        new = new_value(value, n, sem->max_value);
    } while (!rt_atomic_compare_exchange_weak(&sem->value, &value, new,
                                              RT_ATOMIC_RELEASE,
                                              RT_ATOMIC_RELAXED));
    rt_trace_sem_update(sem, value, new);
}