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 if (vs->disconnecting == FALSE) {
152 vs->ioc_tag = qio_channel_add_watch(
153 vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL);
154 }
155 }
156 buffer_move(&vs->output, &vs->jobs_buffer);
157
158 if (vs->job_update == VNC_STATE_UPDATE_FORCE) {
159 vs->force_update_offset = vs->output.offset;
160 }
161 vs->job_update = VNC_STATE_UPDATE_NONE;
162 }
163 flush = vs->ioc != NULL && vs->abort != true;
164 vnc_unlock_output(vs);
165
166 if (flush) {
167 vnc_flush(vs);
168 }
169}
170
171
172
173
174static void vnc_async_encoding_start(VncState *orig, VncState *local)
175{
176 buffer_init(&local->output, "vnc-worker-output");
177 local->sioc = NULL;
178 local->ioc = NULL;
179
180 local->vnc_encoding = orig->vnc_encoding;
181 local->features = orig->features;
182 local->vd = orig->vd;
183 local->lossy_rect = orig->lossy_rect;
184 local->write_pixels = orig->write_pixels;
185 local->client_pf = orig->client_pf;
186 local->client_be = orig->client_be;
187 local->tight = orig->tight;
188 local->zlib = orig->zlib;
189 local->hextile = orig->hextile;
190 local->zrle = orig->zrle;
191}
192
193static void vnc_async_encoding_end(VncState *orig, VncState *local)
194{
195 orig->tight = local->tight;
196 orig->zlib = local->zlib;
197 orig->hextile = local->hextile;
198 orig->zrle = local->zrle;
199 orig->lossy_rect = local->lossy_rect;
200}
201
202static int vnc_worker_thread_loop(VncJobQueue *queue)
203{
204 VncJob *job;
205 VncRectEntry *entry, *tmp;
206 VncState vs = {};
207 int n_rectangles;
208 int saved_offset;
209
210 vnc_lock_queue(queue);
211 while (QTAILQ_EMPTY(&queue->jobs) && !queue->exit) {
212 qemu_cond_wait(&queue->cond, &queue->mutex);
213 }
214
215 job = QTAILQ_FIRST(&queue->jobs);
216 vnc_unlock_queue(queue);
217
218 if (queue->exit) {
219 return -1;
220 }
221
222 vnc_lock_output(job->vs);
223 if (job->vs->ioc == NULL || job->vs->abort == true) {
224 vnc_unlock_output(job->vs);
225 goto disconnected;
226 }
227 if (buffer_empty(&job->vs->output)) {
228
229
230
231
232
233 buffer_move_empty(&vs.output, &job->vs->output);
234 }
235 vnc_unlock_output(job->vs);
236
237
238 vnc_async_encoding_start(job->vs, &vs);
239
240
241 n_rectangles = 0;
242 vnc_write_u8(&vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
243 vnc_write_u8(&vs, 0);
244 saved_offset = vs.output.offset;
245 vnc_write_u16(&vs, 0);
246
247 vnc_lock_display(job->vs->vd);
248 QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) {
249 int n;
250
251 if (job->vs->ioc == NULL) {
252 vnc_unlock_display(job->vs->vd);
253
254 vnc_async_encoding_end(job->vs, &vs);
255 goto disconnected;
256 }
257
258 n = vnc_send_framebuffer_update(&vs, entry->rect.x, entry->rect.y,
259 entry->rect.w, entry->rect.h);
260
261 if (n >= 0) {
262 n_rectangles += n;
263 }
264 g_free(entry);
265 }
266 vnc_unlock_display(job->vs->vd);
267
268
269 vs.output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
270 vs.output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
271
272 vnc_lock_output(job->vs);
273 if (job->vs->ioc != NULL) {
274 buffer_move(&job->vs->jobs_buffer, &vs.output);
275
276 vnc_async_encoding_end(job->vs, &vs);
277
278 qemu_bh_schedule(job->vs->bh);
279 } else {
280 buffer_reset(&vs.output);
281
282 vnc_async_encoding_end(job->vs, &vs);
283 }
284 vnc_unlock_output(job->vs);
285
286disconnected:
287 vnc_lock_queue(queue);
288 QTAILQ_REMOVE(&queue->jobs, job, next);
289 vnc_unlock_queue(queue);
290 qemu_cond_broadcast(&queue->cond);
291 g_free(job);
292 return 0;
293}
294
295static VncJobQueue *vnc_queue_init(void)
296{
297 VncJobQueue *queue = g_new0(VncJobQueue, 1);
298
299 qemu_cond_init(&queue->cond);
300 qemu_mutex_init(&queue->mutex);
301 QTAILQ_INIT(&queue->jobs);
302 return queue;
303}
304
305static void vnc_queue_clear(VncJobQueue *q)
306{
307 qemu_cond_destroy(&queue->cond);
308 qemu_mutex_destroy(&queue->mutex);
309 g_free(q);
310 queue = NULL;
311}
312
313static void *vnc_worker_thread(void *arg)
314{
315 VncJobQueue *queue = arg;
316
317 qemu_thread_get_self(&queue->thread);
318
319 while (!vnc_worker_thread_loop(queue)) ;
320 vnc_queue_clear(queue);
321 return NULL;
322}
323
324static bool vnc_worker_thread_running(void)
325{
326 return queue;
327}
328
329void vnc_start_worker_thread(void)
330{
331 VncJobQueue *q;
332
333 if (vnc_worker_thread_running())
334 return ;
335
336 q = vnc_queue_init();
337 qemu_thread_create(&q->thread, "vnc_worker", vnc_worker_thread, q,
338 QEMU_THREAD_DETACHED);
339 queue = q;
340}
341