LXR qemu/util/coroutine-ucontext.c

   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 <ucontext.h>
  27#include "qemu-common.h"
  28#include "qemu/coroutine_int.h"
  29
  30#ifdef CONFIG_VALGRIND_H
  31#include <valgrind/valgrind.h>
  32#endif
  33
  34typedef struct {
  35    Coroutine base;
  36    void *stack;
  37    size_t stack_size;
  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 */
  49static __thread CoroutineUContext leader;
  50static __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 */
  57union cc_arg {
  58    void *p;
  59    int i[2];
  60};
  61
  62static 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
  84Coroutine *qemu_coroutine_new(void)
  85{
  86    CoroutineUContext *co;
  87    ucontext_t old_uc, uc;
  88    sigjmp_buf old_env;
  89    union cc_arg arg = {0};
  90
  91    /* The ucontext functions preserve signal masks which incurs a
  92     * system call overhead.  sigsetjmp(buf, 0)/siglongjmp() does not
  93     * preserve signal masks but only works on the current stack.
  94     * Since we need a way to create and switch to a new stack, use
  95     * the ucontext functions for that but sigsetjmp()/siglongjmp() for
  96     * everything else.
  97     */
  98
  99    if (getcontext(&uc) == -1) {
 100        abort();
 101    }
 102
 103    co = g_malloc0(sizeof(*co));
 104    co->stack_size = COROUTINE_STACK_SIZE;
 105    co->stack = qemu_alloc_stack(&co->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 = co->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 + co->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
 136static 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
 145void 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    qemu_free_stack(co->stack, co->stack_size);
 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 */
 165CoroutineAction __attribute__((noinline))
 166qemu_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
 182Coroutine *qemu_coroutine_self(void)
 183{
 184    if (!current) {
 185        current = &leader.base;
 186    }
 187    return current;
 188}
 189
 190bool qemu_in_coroutine(void)
 191{
 192    return current && current->caller;
 193}
 194