1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include "qemu/osdep.h"
30#include "vnc.h"
31#include "vnc-jobs.h"
32#include "qemu/sockets.h"
33#include "qemu/main-loop.h"
34#include "block/aio.h"
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55struct VncJobQueue {
56 QemuCond cond;
57 QemuMutex mutex;
58 QemuThread thread;
59 bool exit;
60 QTAILQ_HEAD(, VncJob) jobs;
61};
62
63typedef struct VncJobQueue VncJobQueue;
64
65
66
67
68
69static VncJobQueue *queue;
70
71static void vnc_lock_queue(VncJobQueue *queue)
72{
73 qemu_mutex_lock(&queue->mutex);
74}
75
76static void vnc_unlock_queue(VncJobQueue *queue)
77{
78 qemu_mutex_unlock(&queue->mutex);
79}
80
81VncJob *vnc_job_new(VncState *vs)
82{
83 VncJob *job = g_new0(VncJob, 1);
84
85 job->vs = vs;
86 vnc_lock_queue(queue);
87 QLIST_INIT(&job->rectangles);
88 vnc_unlock_queue(queue);
89 return job;
90}
91
92int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h)
93{
94 VncRectEntry *entry = g_new0(VncRectEntry, 1);
95
96 entry->rect.x = x;
97 entry->rect.y = y;
98 entry->rect.w = w;
99 entry->rect.h = h;
100
101 vnc_lock_queue(queue);
102 QLIST_INSERT_HEAD(&job->rectangles, entry, next);
103 vnc_unlock_queue(queue);
104 return 1;
105}
106
107void vnc_job_push(VncJob *job)
108{
109 vnc_lock_queue(queue);
110 if (queue->exit || QLIST_EMPTY(&job->rectangles)) {
111 g_free(job);
112 } else {
113 QTAILQ_INSERT_TAIL(&queue->jobs, job, next);
114 qemu_cond_broadcast(&queue->cond);
115 }
116 vnc_unlock_queue(queue);
117}
118
119static bool vnc_has_job_locked(VncState *vs)
120{
121 VncJob *job;
122
123 QTAILQ_FOREACH(job, &queue->jobs, next) {
124 if (job->vs == vs || !vs) {
125 return true;
126 }
127 }
128 return false;
129}
130
131void vnc_jobs_join(VncState *vs)
132{
133 vnc_lock_queue(queue);
134 while (vnc_has_job_locked(vs)) {
135 qemu_cond_wait(&queue->cond, &queue->mutex);
136 }
137 vnc_unlock_queue(queue);
138 vnc_jobs_consume_buffer(vs);
139}
140
141void vnc_jobs_consume_buffer(VncState *vs)
142{
143 bool flush;
144
145 vnc_lock_output(vs);
146 if (vs->jobs_buffer.offset) {
147 if (vs->ioc != NULL && buffer_empty(&vs->output)) {
148 if (vs->ioc_tag) {
149 g_source_remove(vs->ioc_tag);
150 }
151 vs->ioc_tag = qio_channel_add_watch(
152 vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL);
153 }
154 buffer_move(&vs->output, &vs->jobs_buffer);
155 }
156 flush = vs->ioc != NULL && vs->abort != true;
157 vnc_unlock_output(vs);
158
159 if (flush) {
160 vnc_flush(vs);
161 }
162}
163
164
165
166
167static void vnc_async_encoding_start(VncState *orig, VncState *local)
168{
169 buffer_init(&local->output, "vnc-worker-output");
170 local->sioc = NULL;
171 local->ioc = NULL;
172
173 local->vnc_encoding = orig->vnc_encoding;
174 local->features = orig->features;
175 local->vd = orig->vd;
176 local->lossy_rect = orig->lossy_rect;
177 local->write_pixels = orig->write_pixels;
178 local->client_pf = orig->client_pf;
179 local->client_be = orig->client_be;
180 local->tight = orig->tight;
181 local->zlib = orig->zlib;
182 local->hextile = orig->hextile;
183 local->zrle = orig->zrle;
184}
185
186static void vnc_async_encoding_end(VncState *orig, VncState *local)
187{
188 orig->tight = local->tight;
189 orig->zlib = local->zlib;
190 orig->hextile = local->hextile;
191 orig->zrle = local->zrle;
192 orig->lossy_rect = local->lossy_rect;
193}
194
195static int vnc_worker_thread_loop(VncJobQueue *queue)
196{
197 VncJob *job;
198 VncRectEntry *entry, *tmp;
199 VncState vs = {};
200 int n_rectangles;
201 int saved_offset;
202
203 vnc_lock_queue(queue);
204 while (QTAILQ_EMPTY(&queue->jobs) && !queue->exit) {
205 qemu_cond_wait(&queue->cond, &queue->mutex);
206 }
207
208 job = QTAILQ_FIRST(&queue->jobs);
209 vnc_unlock_queue(queue);
210
211 if (queue->exit) {
212 return -1;
213 }
214
215 vnc_lock_output(job->vs);
216 if (job->vs->ioc == NULL || job->vs->abort == true) {
217 vnc_unlock_output(job->vs);
218 goto disconnected;
219 }
220 if (buffer_empty(&job->vs->output)) {
221
222
223
224
225
226 buffer_move_empty(&vs.output, &job->vs->output);
227 }
228 vnc_unlock_output(job->vs);
229
230
231 vnc_async_encoding_start(job->vs, &vs);
232
233
234 n_rectangles = 0;
235 vnc_write_u8(&vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
236 vnc_write_u8(&vs, 0);
237 saved_offset = vs.output.offset;
238 vnc_write_u16(&vs, 0);
239
240 vnc_lock_display(job->vs->vd);
241 QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) {
242 int n;
243
244 if (job->vs->ioc == NULL) {
245 vnc_unlock_display(job->vs->vd);
246
247 vnc_async_encoding_end(job->vs, &vs);
248 goto disconnected;
249 }
250
251 n = vnc_send_framebuffer_update(&vs, entry->rect.x, entry->rect.y,
252 entry->rect.w, entry->rect.h);
253
254 if (n >= 0) {
255 n_rectangles += n;
256 }
257 g_free(entry);
258 }
259 vnc_unlock_display(job->vs->vd);
260
261
262 vs.output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
263 vs.output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
264
265 vnc_lock_output(job->vs);
266 if (job->vs->ioc != NULL) {
267 buffer_move(&job->vs->jobs_buffer, &vs.output);
268
269 vnc_async_encoding_end(job->vs, &vs);
270
271 qemu_bh_schedule(job->vs->bh);
272 } else {
273 buffer_reset(&vs.output);
274
275 vnc_async_encoding_end(job->vs, &vs);
276 }
277 vnc_unlock_output(job->vs);
278
279disconnected:
280 vnc_lock_queue(queue);
281 QTAILQ_REMOVE(&queue->jobs, job, next);
282 vnc_unlock_queue(queue);
283 qemu_cond_broadcast(&queue->cond);
284 g_free(job);
285 return 0;
286}
287
288static VncJobQueue *vnc_queue_init(void)
289{
290 VncJobQueue *queue = g_new0(VncJobQueue, 1);
291
292 qemu_cond_init(&queue->cond);
293 qemu_mutex_init(&queue->mutex);
294 QTAILQ_INIT(&queue->jobs);
295 return queue;
296}
297
298static void vnc_queue_clear(VncJobQueue *q)
299{
300 qemu_cond_destroy(&queue->cond);
301 qemu_mutex_destroy(&queue->mutex);
302 g_free(q);
303 queue = NULL;
304}
305
306static void *vnc_worker_thread(void *arg)
307{
308 VncJobQueue *queue = arg;
309
310 qemu_thread_get_self(&queue->thread);
311
312 while (!vnc_worker_thread_loop(queue)) ;
313 vnc_queue_clear(queue);
314 return NULL;
315}
316
317static bool vnc_worker_thread_running(void)
318{
319 return queue;
320}
321
322void vnc_start_worker_thread(void)
323{
324 VncJobQueue *q;
325
326 if (vnc_worker_thread_running())
327 return ;
328
329 q = vnc_queue_init();
330 qemu_thread_create(&q->thread, "vnc_worker", vnc_worker_thread, q,
331 QEMU_THREAD_DETACHED);
332 queue = q;
333}
334