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#include "qemu/osdep.h"
26#include "qemu-common.h"
27#include "qemu/coroutine.h"
28#include "qemu/coroutine_int.h"
29#include "qemu/queue.h"
30#include "trace.h"
31
32void qemu_co_queue_init(CoQueue *queue)
33{
34 QTAILQ_INIT(&queue->entries);
35}
36
37void coroutine_fn qemu_co_queue_wait(CoQueue *queue)
38{
39 Coroutine *self = qemu_coroutine_self();
40 QTAILQ_INSERT_TAIL(&queue->entries, self, co_queue_next);
41 qemu_coroutine_yield();
42 assert(qemu_in_coroutine());
43}
44
45
46
47
48
49
50
51
52
53void qemu_co_queue_run_restart(Coroutine *co)
54{
55 Coroutine *next;
56
57 trace_qemu_co_queue_run_restart(co);
58 while ((next = QTAILQ_FIRST(&co->co_queue_wakeup))) {
59 QTAILQ_REMOVE(&co->co_queue_wakeup, next, co_queue_next);
60 qemu_coroutine_enter(next, NULL);
61 }
62}
63
64static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
65{
66 Coroutine *self = qemu_coroutine_self();
67 Coroutine *next;
68
69 if (QTAILQ_EMPTY(&queue->entries)) {
70 return false;
71 }
72
73 while ((next = QTAILQ_FIRST(&queue->entries)) != NULL) {
74 QTAILQ_REMOVE(&queue->entries, next, co_queue_next);
75 QTAILQ_INSERT_TAIL(&self->co_queue_wakeup, next, co_queue_next);
76 trace_qemu_co_queue_next(next);
77 if (single) {
78 break;
79 }
80 }
81 return true;
82}
83
84bool coroutine_fn qemu_co_queue_next(CoQueue *queue)
85{
86 assert(qemu_in_coroutine());
87 return qemu_co_queue_do_restart(queue, true);
88}
89
90void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue)
91{
92 assert(qemu_in_coroutine());
93 qemu_co_queue_do_restart(queue, false);
94}
95
96bool qemu_co_enter_next(CoQueue *queue)
97{
98 Coroutine *next;
99
100 next = QTAILQ_FIRST(&queue->entries);
101 if (!next) {
102 return false;
103 }
104
105 QTAILQ_REMOVE(&queue->entries, next, co_queue_next);
106 qemu_coroutine_enter(next, NULL);
107 return true;
108}
109
110bool qemu_co_queue_empty(CoQueue *queue)
111{
112 return QTAILQ_FIRST(&queue->entries) == NULL;
113}
114
115void qemu_co_mutex_init(CoMutex *mutex)
116{
117 memset(mutex, 0, sizeof(*mutex));
118 qemu_co_queue_init(&mutex->queue);
119}
120
121void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
122{
123 Coroutine *self = qemu_coroutine_self();
124
125 trace_qemu_co_mutex_lock_entry(mutex, self);
126
127 while (mutex->locked) {
128 qemu_co_queue_wait(&mutex->queue);
129 }
130
131 mutex->locked = true;
132
133 trace_qemu_co_mutex_lock_return(mutex, self);
134}
135
136void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
137{
138 Coroutine *self = qemu_coroutine_self();
139
140 trace_qemu_co_mutex_unlock_entry(mutex, self);
141
142 assert(mutex->locked == true);
143 assert(qemu_in_coroutine());
144
145 mutex->locked = false;
146 qemu_co_queue_next(&mutex->queue);
147
148 trace_qemu_co_mutex_unlock_return(mutex, self);
149}
150
151void qemu_co_rwlock_init(CoRwlock *lock)
152{
153 memset(lock, 0, sizeof(*lock));
154 qemu_co_queue_init(&lock->queue);
155}
156
157void qemu_co_rwlock_rdlock(CoRwlock *lock)
158{
159 while (lock->writer) {
160 qemu_co_queue_wait(&lock->queue);
161 }
162 lock->reader++;
163}
164
165void qemu_co_rwlock_unlock(CoRwlock *lock)
166{
167 assert(qemu_in_coroutine());
168 if (lock->writer) {
169 lock->writer = false;
170 qemu_co_queue_restart_all(&lock->queue);
171 } else {
172 lock->reader--;
173 assert(lock->reader >= 0);
174
175 if (!lock->reader) {
176 qemu_co_queue_next(&lock->queue);
177 }
178 }
179}
180
181void qemu_co_rwlock_wrlock(CoRwlock *lock)
182{
183 while (lock->writer || lock->reader) {
184 qemu_co_queue_wait(&lock->queue);
185 }
186 lock->writer = true;
187}
188