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