ahci: Fix FIS decomposition
[qemu.git] / qemu-coroutine.c
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 "block/coroutine.h"
19 #include "block/coroutine_int.h"
20
21 enum {
22 POOL_DEFAULT_SIZE = 64,
23 };
24
25 /** Free list to speed up creation */
26 static QemuMutex pool_lock;
27 static QSLIST_HEAD(, Coroutine) pool = QSLIST_HEAD_INITIALIZER(pool);
28 static unsigned int pool_size;
29 static unsigned int pool_max_size = POOL_DEFAULT_SIZE;
30
31 Coroutine *qemu_coroutine_create(CoroutineEntry *entry)
32 {
33 Coroutine *co = NULL;
34
35 if (CONFIG_COROUTINE_POOL) {
36 qemu_mutex_lock(&pool_lock);
37 co = QSLIST_FIRST(&pool);
38 if (co) {
39 QSLIST_REMOVE_HEAD(&pool, pool_next);
40 pool_size--;
41 }
42 qemu_mutex_unlock(&pool_lock);
43 }
44
45 if (!co) {
46 co = qemu_coroutine_new();
47 }
48
49 co->entry = entry;
50 QTAILQ_INIT(&co->co_queue_wakeup);
51 return co;
52 }
53
54 static void coroutine_delete(Coroutine *co)
55 {
56 if (CONFIG_COROUTINE_POOL) {
57 qemu_mutex_lock(&pool_lock);
58 if (pool_size < pool_max_size) {
59 QSLIST_INSERT_HEAD(&pool, co, pool_next);
60 co->caller = NULL;
61 pool_size++;
62 qemu_mutex_unlock(&pool_lock);
63 return;
64 }
65 qemu_mutex_unlock(&pool_lock);
66 }
67
68 qemu_coroutine_delete(co);
69 }
70
71 static void __attribute__((constructor)) coroutine_pool_init(void)
72 {
73 qemu_mutex_init(&pool_lock);
74 }
75
76 static void __attribute__((destructor)) coroutine_pool_cleanup(void)
77 {
78 Coroutine *co;
79 Coroutine *tmp;
80
81 QSLIST_FOREACH_SAFE(co, &pool, pool_next, tmp) {
82 QSLIST_REMOVE_HEAD(&pool, pool_next);
83 qemu_coroutine_delete(co);
84 }
85
86 qemu_mutex_destroy(&pool_lock);
87 }
88
89 static void coroutine_swap(Coroutine *from, Coroutine *to)
90 {
91 CoroutineAction ret;
92
93 ret = qemu_coroutine_switch(from, to, COROUTINE_YIELD);
94
95 qemu_co_queue_run_restart(to);
96
97 switch (ret) {
98 case COROUTINE_YIELD:
99 return;
100 case COROUTINE_TERMINATE:
101 trace_qemu_coroutine_terminate(to);
102 coroutine_delete(to);
103 return;
104 default:
105 abort();
106 }
107 }
108
109 void qemu_coroutine_enter(Coroutine *co, void *opaque)
110 {
111 Coroutine *self = qemu_coroutine_self();
112
113 trace_qemu_coroutine_enter(self, co, opaque);
114
115 if (co->caller) {
116 fprintf(stderr, "Co-routine re-entered recursively\n");
117 abort();
118 }
119
120 co->caller = self;
121 co->entry_arg = opaque;
122 coroutine_swap(self, co);
123 }
124
125 void coroutine_fn qemu_coroutine_yield(void)
126 {
127 Coroutine *self = qemu_coroutine_self();
128 Coroutine *to = self->caller;
129
130 trace_qemu_coroutine_yield(self, to);
131
132 if (!to) {
133 fprintf(stderr, "Co-routine is yielding to no one\n");
134 abort();
135 }
136
137 self->caller = NULL;
138 coroutine_swap(self, to);
139 }
140
141 void qemu_coroutine_adjust_pool_size(int n)
142 {
143 qemu_mutex_lock(&pool_lock);
144
145 pool_max_size += n;
146
147 /* Callers should never take away more than they added */
148 assert(pool_max_size >= POOL_DEFAULT_SIZE);
149
150 /* Trim oversized pool down to new max */
151 while (pool_size > pool_max_size) {
152 Coroutine *co = QSLIST_FIRST(&pool);
153 QSLIST_REMOVE_HEAD(&pool, pool_next);
154 pool_size--;
155 qemu_coroutine_delete(co);
156 }
157
158 qemu_mutex_unlock(&pool_lock);
159 }