2 * ucontext coroutine initialization code
4 * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
5 * Copyright (C) 2011 Kevin Wolf <kwolf@redhat.com>
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.0 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
21 /* XXX Is there a nicer way to disable glibc's stack check for longjmp? */
22 #ifdef _FORTIFY_SOURCE
23 #undef _FORTIFY_SOURCE
30 #include "qemu-common.h"
31 #include "block/coroutine_int.h"
33 #ifdef CONFIG_VALGRIND_H
34 #include <valgrind/valgrind.h>
38 /* Maximum free pool size prevents holding too many freed coroutines */
42 /** Free list to speed up creation */
43 static QSLIST_HEAD(, Coroutine
) pool
= QSLIST_HEAD_INITIALIZER(pool
);
44 static unsigned int pool_size
;
51 #ifdef CONFIG_VALGRIND_H
52 unsigned int valgrind_stack_id
;
58 * Per-thread coroutine bookkeeping
61 /** Currently executing coroutine */
64 /** The default coroutine */
65 CoroutineUContext leader
;
66 } CoroutineThreadState
;
68 static pthread_key_t thread_state_key
;
71 * va_args to makecontext() must be type 'int', so passing
72 * the pointer we need may require several int args. This
73 * union is a quick hack to let us do that
80 static CoroutineThreadState
*coroutine_get_thread_state(void)
82 CoroutineThreadState
*s
= pthread_getspecific(thread_state_key
);
85 s
= g_malloc0(sizeof(*s
));
86 s
->current
= &s
->leader
.base
;
87 pthread_setspecific(thread_state_key
, s
);
92 static void qemu_coroutine_thread_cleanup(void *opaque
)
94 CoroutineThreadState
*s
= opaque
;
99 static void __attribute__((destructor
)) coroutine_cleanup(void)
104 QSLIST_FOREACH_SAFE(co
, &pool
, pool_next
, tmp
) {
105 g_free(DO_UPCAST(CoroutineUContext
, base
, co
)->stack
);
110 static void __attribute__((constructor
)) coroutine_init(void)
114 ret
= pthread_key_create(&thread_state_key
, qemu_coroutine_thread_cleanup
);
116 fprintf(stderr
, "unable to create leader key: %s\n", strerror(errno
));
121 static void coroutine_trampoline(int i0
, int i1
)
124 CoroutineUContext
*self
;
132 /* Initialize longjmp environment and switch back the caller */
133 if (!sigsetjmp(self
->env
, 0)) {
134 siglongjmp(*(sigjmp_buf
*)co
->entry_arg
, 1);
138 co
->entry(co
->entry_arg
);
139 qemu_coroutine_switch(co
, co
->caller
, COROUTINE_TERMINATE
);
143 static Coroutine
*coroutine_new(void)
145 const size_t stack_size
= 1 << 20;
146 CoroutineUContext
*co
;
147 ucontext_t old_uc
, uc
;
149 union cc_arg arg
= {0};
151 /* The ucontext functions preserve signal masks which incurs a
152 * system call overhead. sigsetjmp(buf, 0)/siglongjmp() does not
153 * preserve signal masks but only works on the current stack.
154 * Since we need a way to create and switch to a new stack, use
155 * the ucontext functions for that but sigsetjmp()/siglongjmp() for
159 if (getcontext(&uc
) == -1) {
163 co
= g_malloc0(sizeof(*co
));
164 co
->stack
= g_malloc(stack_size
);
165 co
->base
.entry_arg
= &old_env
; /* stash away our jmp_buf */
167 uc
.uc_link
= &old_uc
;
168 uc
.uc_stack
.ss_sp
= co
->stack
;
169 uc
.uc_stack
.ss_size
= stack_size
;
170 uc
.uc_stack
.ss_flags
= 0;
172 #ifdef CONFIG_VALGRIND_H
173 co
->valgrind_stack_id
=
174 VALGRIND_STACK_REGISTER(co
->stack
, co
->stack
+ stack_size
);
179 makecontext(&uc
, (void (*)(void))coroutine_trampoline
,
180 2, arg
.i
[0], arg
.i
[1]);
182 /* swapcontext() in, siglongjmp() back out */
183 if (!sigsetjmp(old_env
, 0)) {
184 swapcontext(&old_uc
, &uc
);
189 Coroutine
*qemu_coroutine_new(void)
193 co
= QSLIST_FIRST(&pool
);
195 QSLIST_REMOVE_HEAD(&pool
, pool_next
);
198 co
= coroutine_new();
203 #ifdef CONFIG_VALGRIND_H
204 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
205 /* Work around an unused variable in the valgrind.h macro... */
206 #pragma GCC diagnostic ignored "-Wunused-but-set-variable"
208 static inline void valgrind_stack_deregister(CoroutineUContext
*co
)
210 VALGRIND_STACK_DEREGISTER(co
->valgrind_stack_id
);
212 #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE
213 #pragma GCC diagnostic error "-Wunused-but-set-variable"
217 void qemu_coroutine_delete(Coroutine
*co_
)
219 CoroutineUContext
*co
= DO_UPCAST(CoroutineUContext
, base
, co_
);
221 if (pool_size
< POOL_MAX_SIZE
) {
222 QSLIST_INSERT_HEAD(&pool
, &co
->base
, pool_next
);
223 co
->base
.caller
= NULL
;
228 #ifdef CONFIG_VALGRIND_H
229 valgrind_stack_deregister(co
);
236 CoroutineAction
qemu_coroutine_switch(Coroutine
*from_
, Coroutine
*to_
,
237 CoroutineAction action
)
239 CoroutineUContext
*from
= DO_UPCAST(CoroutineUContext
, base
, from_
);
240 CoroutineUContext
*to
= DO_UPCAST(CoroutineUContext
, base
, to_
);
241 CoroutineThreadState
*s
= coroutine_get_thread_state();
246 ret
= sigsetjmp(from
->env
, 0);
248 siglongjmp(to
->env
, action
);
253 Coroutine
*qemu_coroutine_self(void)
255 CoroutineThreadState
*s
= coroutine_get_thread_state();
260 bool qemu_in_coroutine(void)
262 CoroutineThreadState
*s
= pthread_getspecific(thread_state_key
);
264 return s
&& s
->current
->caller
;