1 /* 2 * QEMU coroutines 3 * 4 * Copyright IBM, Corp. 2011 5 * 6 * Authors: 7 * Stefan Hajnoczi <stefanha@linux.vnet.ibm.com> 8 * Kevin Wolf <kwolf@redhat.com> 9 * 10 * This work is licensed under the terms of the GNU LGPL, version 2 or later. 11 * See the COPYING.LIB file in the top-level directory. 12 * 13 */ 14 15 #include "trace.h" 16 #include "qemu-common.h" 17 #include "qemu/thread.h" 18 #include "qemu/atomic.h" 19 #include "qemu/coroutine.h" 20 #include "qemu/coroutine_int.h" 21 22 enum { 23 POOL_BATCH_SIZE = 64, 24 }; 25 26 /** Free list to speed up creation */ 27 static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool); 28 static unsigned int release_pool_size; 29 static __thread QSLIST_HEAD(, Coroutine) alloc_pool = QSLIST_HEAD_INITIALIZER(pool); 30 static __thread unsigned int alloc_pool_size; 31 static __thread Notifier coroutine_pool_cleanup_notifier; 32 33 static void coroutine_pool_cleanup(Notifier *n, void *value) 34 { 35 Coroutine *co; 36 Coroutine *tmp; 37 38 QSLIST_FOREACH_SAFE(co, &alloc_pool, pool_next, tmp) { 39 QSLIST_REMOVE_HEAD(&alloc_pool, pool_next); 40 qemu_coroutine_delete(co); 41 } 42 } 43 44 Coroutine *qemu_coroutine_create(CoroutineEntry *entry) 45 { 46 Coroutine *co = NULL; 47 48 if (CONFIG_COROUTINE_POOL) { 49 co = QSLIST_FIRST(&alloc_pool); 50 if (!co) { 51 if (release_pool_size > POOL_BATCH_SIZE) { 52 /* Slow path; a good place to register the destructor, too. */ 53 if (!coroutine_pool_cleanup_notifier.notify) { 54 coroutine_pool_cleanup_notifier.notify = coroutine_pool_cleanup; 55 qemu_thread_atexit_add(&coroutine_pool_cleanup_notifier); 56 } 57 58 /* This is not exact; there could be a little skew between 59 * release_pool_size and the actual size of release_pool. But 60 * it is just a heuristic, it does not need to be perfect. 61 */ 62 alloc_pool_size = atomic_xchg(&release_pool_size, 0); 63 QSLIST_MOVE_ATOMIC(&alloc_pool, &release_pool); 64 co = QSLIST_FIRST(&alloc_pool); 65 } 66 } 67 if (co) { 68 QSLIST_REMOVE_HEAD(&alloc_pool, pool_next); 69 alloc_pool_size--; 70 } 71 } 72 73 if (!co) { 74 co = qemu_coroutine_new(); 75 } 76 77 co->entry = entry; 78 QTAILQ_INIT(&co->co_queue_wakeup); 79 return co; 80 } 81 82 static void coroutine_delete(Coroutine *co) 83 { 84 co->caller = NULL; 85 86 if (CONFIG_COROUTINE_POOL) { 87 if (release_pool_size < POOL_BATCH_SIZE * 2) { 88 QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next); 89 atomic_inc(&release_pool_size); 90 return; 91 } 92 if (alloc_pool_size < POOL_BATCH_SIZE) { 93 QSLIST_INSERT_HEAD(&alloc_pool, co, pool_next); 94 alloc_pool_size++; 95 return; 96 } 97 } 98 99 qemu_coroutine_delete(co); 100 } 101 102 void qemu_coroutine_enter(Coroutine *co, void *opaque) 103 { 104 Coroutine *self = qemu_coroutine_self(); 105 CoroutineAction ret; 106 107 trace_qemu_coroutine_enter(self, co, opaque); 108 109 if (co->caller) { 110 fprintf(stderr, "Co-routine re-entered recursively\n"); 111 abort(); 112 } 113 114 co->caller = self; 115 co->entry_arg = opaque; 116 ret = qemu_coroutine_switch(self, co, COROUTINE_ENTER); 117 118 qemu_co_queue_run_restart(co); 119 120 switch (ret) { 121 case COROUTINE_YIELD: 122 return; 123 case COROUTINE_TERMINATE: 124 trace_qemu_coroutine_terminate(co); 125 coroutine_delete(co); 126 return; 127 default: 128 abort(); 129 } 130 } 131 132 void coroutine_fn qemu_coroutine_yield(void) 133 { 134 Coroutine *self = qemu_coroutine_self(); 135 Coroutine *to = self->caller; 136 137 trace_qemu_coroutine_yield(self, to); 138 139 if (!to) { 140 fprintf(stderr, "Co-routine is yielding to no one\n"); 141 abort(); 142 } 143 144 self->caller = NULL; 145 qemu_coroutine_switch(self, to, COROUTINE_YIELD); 146 } 147