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 "qemu/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 } 195