]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * ucontext coroutine initialization code | |
3 | * | |
4 | * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws> | |
5 | * Copyright (C) 2011 Kevin Wolf <kwolf@redhat.com> | |
6 | * | |
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. | |
11 | * | |
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. | |
16 | * | |
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/>. | |
19 | */ | |
20 | ||
21 | /* XXX Is there a nicer way to disable glibc's stack check for longjmp? */ | |
22 | #ifdef _FORTIFY_SOURCE | |
23 | #undef _FORTIFY_SOURCE | |
24 | #endif | |
25 | #include <stdlib.h> | |
26 | #include <setjmp.h> | |
27 | #include <stdint.h> | |
28 | #include <ucontext.h> | |
29 | #include "qemu-common.h" | |
30 | #include "block/coroutine_int.h" | |
31 | ||
32 | #ifdef CONFIG_VALGRIND_H | |
33 | #include <valgrind/valgrind.h> | |
34 | #endif | |
35 | ||
36 | typedef struct { | |
37 | Coroutine base; | |
38 | void *stack; | |
39 | sigjmp_buf env; | |
40 | ||
41 | #ifdef CONFIG_VALGRIND_H | |
42 | unsigned int valgrind_stack_id; | |
43 | #endif | |
44 | ||
45 | } CoroutineUContext; | |
46 | ||
47 | /** | |
48 | * Per-thread coroutine bookkeeping | |
49 | */ | |
50 | static __thread CoroutineUContext leader; | |
51 | static __thread Coroutine *current; | |
52 | ||
53 | /* | |
54 | * va_args to makecontext() must be type 'int', so passing | |
55 | * the pointer we need may require several int args. This | |
56 | * union is a quick hack to let us do that | |
57 | */ | |
58 | union cc_arg { | |
59 | void *p; | |
60 | int i[2]; | |
61 | }; | |
62 | ||
63 | static void coroutine_trampoline(int i0, int i1) | |
64 | { | |
65 | union cc_arg arg; | |
66 | CoroutineUContext *self; | |
67 | Coroutine *co; | |
68 | ||
69 | arg.i[0] = i0; | |
70 | arg.i[1] = i1; | |
71 | self = arg.p; | |
72 | co = &self->base; | |
73 | ||
74 | /* Initialize longjmp environment and switch back the caller */ | |
75 | if (!sigsetjmp(self->env, 0)) { | |
76 | siglongjmp(*(sigjmp_buf *)co->entry_arg, 1); | |
77 | } | |
78 | ||
79 | while (true) { | |
80 | co->entry(co->entry_arg); | |
81 | qemu_coroutine_switch(co, co->caller, COROUTINE_TERMINATE); | |
82 | } | |
83 | } | |
84 | ||
85 | Coroutine *qemu_coroutine_new(void) | |
86 | { | |
87 | const size_t stack_size = 1 << 20; | |
88 | CoroutineUContext *co; | |
89 | ucontext_t old_uc, uc; | |
90 | sigjmp_buf old_env; | |
91 | union cc_arg arg = {0}; | |
92 | ||
93 | /* The ucontext functions preserve signal masks which incurs a | |
94 | * system call overhead. sigsetjmp(buf, 0)/siglongjmp() does not | |
95 | * preserve signal masks but only works on the current stack. | |
96 | * Since we need a way to create and switch to a new stack, use | |
97 | * the ucontext functions for that but sigsetjmp()/siglongjmp() for | |
98 | * everything else. | |
99 | */ | |
100 | ||
101 | if (getcontext(&uc) == -1) { | |
102 | abort(); | |
103 | } | |
104 | ||
105 | co = g_malloc0(sizeof(*co)); | |
106 | co->stack = g_malloc(stack_size); | |
107 | co->base.entry_arg = &old_env; /* stash away our jmp_buf */ | |
108 | ||
109 | uc.uc_link = &old_uc; | |
110 | uc.uc_stack.ss_sp = co->stack; | |
111 | uc.uc_stack.ss_size = stack_size; | |
112 | uc.uc_stack.ss_flags = 0; | |
113 | ||
114 | #ifdef CONFIG_VALGRIND_H | |
115 | co->valgrind_stack_id = | |
116 | VALGRIND_STACK_REGISTER(co->stack, co->stack + stack_size); | |
117 | #endif | |
118 | ||
119 | arg.p = co; | |
120 | ||
121 | makecontext(&uc, (void (*)(void))coroutine_trampoline, | |
122 | 2, arg.i[0], arg.i[1]); | |
123 | ||
124 | /* swapcontext() in, siglongjmp() back out */ | |
125 | if (!sigsetjmp(old_env, 0)) { | |
126 | swapcontext(&old_uc, &uc); | |
127 | } | |
128 | return &co->base; | |
129 | } | |
130 | ||
131 | #ifdef CONFIG_VALGRIND_H | |
132 | #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE | |
133 | /* Work around an unused variable in the valgrind.h macro... */ | |
134 | #pragma GCC diagnostic push | |
135 | #pragma GCC diagnostic ignored "-Wunused-but-set-variable" | |
136 | #endif | |
137 | static inline void valgrind_stack_deregister(CoroutineUContext *co) | |
138 | { | |
139 | VALGRIND_STACK_DEREGISTER(co->valgrind_stack_id); | |
140 | } | |
141 | #ifdef CONFIG_PRAGMA_DIAGNOSTIC_AVAILABLE | |
142 | #pragma GCC diagnostic pop | |
143 | #endif | |
144 | #endif | |
145 | ||
146 | void qemu_coroutine_delete(Coroutine *co_) | |
147 | { | |
148 | CoroutineUContext *co = DO_UPCAST(CoroutineUContext, base, co_); | |
149 | ||
150 | #ifdef CONFIG_VALGRIND_H | |
151 | valgrind_stack_deregister(co); | |
152 | #endif | |
153 | ||
154 | g_free(co->stack); | |
155 | g_free(co); | |
156 | } | |
157 | ||
158 | /* This function is marked noinline to prevent GCC from inlining it | |
159 | * into coroutine_trampoline(). If we allow it to do that then it | |
160 | * hoists the code to get the address of the TLS variable "current" | |
161 | * out of the while() loop. This is an invalid transformation because | |
162 | * the sigsetjmp() call may be called when running thread A but | |
163 | * return in thread B, and so we might be in a different thread | |
164 | * context each time round the loop. | |
165 | */ | |
166 | CoroutineAction __attribute__((noinline)) | |
167 | qemu_coroutine_switch(Coroutine *from_, Coroutine *to_, | |
168 | CoroutineAction action) | |
169 | { | |
170 | CoroutineUContext *from = DO_UPCAST(CoroutineUContext, base, from_); | |
171 | CoroutineUContext *to = DO_UPCAST(CoroutineUContext, base, to_); | |
172 | int ret; | |
173 | ||
174 | current = to_; | |
175 | ||
176 | ret = sigsetjmp(from->env, 0); | |
177 | if (ret == 0) { | |
178 | siglongjmp(to->env, action); | |
179 | } | |
180 | return ret; | |
181 | } | |
182 | ||
183 | Coroutine *qemu_coroutine_self(void) | |
184 | { | |
185 | if (!current) { | |
186 | current = &leader.base; | |
187 | } | |
188 | return current; | |
189 | } | |
190 | ||
191 | bool qemu_in_coroutine(void) | |
192 | { | |
193 | return current && current->caller; | |
194 | } |