1 | /* |
2 | * QEMU VNC display driver |
3 | * |
4 | * Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws> |
5 | * Copyright (C) 2006 Fabrice Bellard |
6 | * Copyright (C) 2009 Red Hat, Inc |
7 | * Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com> |
8 | * |
9 | * Permission is hereby granted, free of charge, to any person obtaining a copy |
10 | * of this software and associated documentation files (the "Software"), to deal |
11 | * in the Software without restriction, including without limitation the rights |
12 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
13 | * copies of the Software, and to permit persons to whom the Software is |
14 | * furnished to do so, subject to the following conditions: |
15 | * |
16 | * The above copyright notice and this permission notice shall be included in |
17 | * all copies or substantial portions of the Software. |
18 | * |
19 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
20 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
21 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
22 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
23 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
24 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
25 | * THE SOFTWARE. |
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 | * Locking: |
38 | * |
39 | * There are three levels of locking: |
40 | * - jobs queue lock: for each operation on the queue (push, pop, isEmpty?) |
41 | * - VncDisplay global lock: mainly used for framebuffer updates to avoid |
42 | * screen corruption if the framebuffer is updated |
43 | * while the worker is doing something. |
44 | * - VncState::output lock: used to make sure the output buffer is not corrupted |
45 | * if two threads try to write on it at the same time |
46 | * |
47 | * While the VNC worker thread is working, the VncDisplay global lock is held |
48 | * to avoid screen corruption (this does not block vnc_refresh() because it |
49 | * uses trylock()) but the output lock is not held because the thread works on |
50 | * its own output buffer. |
51 | * When the encoding job is done, the worker thread will hold the output lock |
52 | * and copy its output buffer in vs->output. |
53 | */ |
54 | |
55 | struct VncJobQueue { |
56 | QemuCond cond; |
57 | QemuMutex mutex; |
58 | QemuThread thread; |
59 | bool exit; |
60 | QTAILQ_HEAD(, VncJob) jobs; |
61 | }; |
62 | |
63 | typedef struct VncJobQueue VncJobQueue; |
64 | |
65 | /* |
66 | * We use a single global queue, but most of the functions are |
67 | * already reentrant, so we can easily add more than one encoding thread |
68 | */ |
69 | static VncJobQueue *queue; |
70 | |
71 | static void vnc_lock_queue(VncJobQueue *queue) |
72 | { |
73 | qemu_mutex_lock(&queue->mutex); |
74 | } |
75 | |
76 | static void vnc_unlock_queue(VncJobQueue *queue) |
77 | { |
78 | qemu_mutex_unlock(&queue->mutex); |
79 | } |
80 | |
81 | VncJob *vnc_job_new(VncState *vs) |
82 | { |
83 | VncJob *job = g_new0(VncJob, 1); |
84 | |
85 | assert(vs->magic == VNC_MAGIC); |
86 | job->vs = vs; |
87 | vnc_lock_queue(queue); |
88 | QLIST_INIT(&job->rectangles); |
89 | vnc_unlock_queue(queue); |
90 | return job; |
91 | } |
92 | |
93 | int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h) |
94 | { |
95 | VncRectEntry *entry = g_new0(VncRectEntry, 1); |
96 | |
97 | entry->rect.x = x; |
98 | entry->rect.y = y; |
99 | entry->rect.w = w; |
100 | entry->rect.h = h; |
101 | |
102 | vnc_lock_queue(queue); |
103 | QLIST_INSERT_HEAD(&job->rectangles, entry, next); |
104 | vnc_unlock_queue(queue); |
105 | return 1; |
106 | } |
107 | |
108 | void vnc_job_push(VncJob *job) |
109 | { |
110 | vnc_lock_queue(queue); |
111 | if (queue->exit || QLIST_EMPTY(&job->rectangles)) { |
112 | g_free(job); |
113 | } else { |
114 | QTAILQ_INSERT_TAIL(&queue->jobs, job, next); |
115 | qemu_cond_broadcast(&queue->cond); |
116 | } |
117 | vnc_unlock_queue(queue); |
118 | } |
119 | |
120 | static bool vnc_has_job_locked(VncState *vs) |
121 | { |
122 | VncJob *job; |
123 | |
124 | QTAILQ_FOREACH(job, &queue->jobs, next) { |
125 | if (job->vs == vs || !vs) { |
126 | return true; |
127 | } |
128 | } |
129 | return false; |
130 | } |
131 | |
132 | void vnc_jobs_join(VncState *vs) |
133 | { |
134 | vnc_lock_queue(queue); |
135 | while (vnc_has_job_locked(vs)) { |
136 | qemu_cond_wait(&queue->cond, &queue->mutex); |
137 | } |
138 | vnc_unlock_queue(queue); |
139 | vnc_jobs_consume_buffer(vs); |
140 | } |
141 | |
142 | void vnc_jobs_consume_buffer(VncState *vs) |
143 | { |
144 | bool flush; |
145 | |
146 | vnc_lock_output(vs); |
147 | if (vs->jobs_buffer.offset) { |
148 | if (vs->ioc != NULL && buffer_empty(&vs->output)) { |
149 | if (vs->ioc_tag) { |
150 | g_source_remove(vs->ioc_tag); |
151 | } |
152 | if (vs->disconnecting == FALSE) { |
153 | vs->ioc_tag = qio_channel_add_watch( |
154 | vs->ioc, G_IO_IN | G_IO_OUT, vnc_client_io, vs, NULL); |
155 | } |
156 | } |
157 | buffer_move(&vs->output, &vs->jobs_buffer); |
158 | |
159 | if (vs->job_update == VNC_STATE_UPDATE_FORCE) { |
160 | vs->force_update_offset = vs->output.offset; |
161 | } |
162 | vs->job_update = VNC_STATE_UPDATE_NONE; |
163 | } |
164 | flush = vs->ioc != NULL && vs->abort != true; |
165 | vnc_unlock_output(vs); |
166 | |
167 | if (flush) { |
168 | vnc_flush(vs); |
169 | } |
170 | } |
171 | |
172 | /* |
173 | * Copy data for local use |
174 | */ |
175 | static void vnc_async_encoding_start(VncState *orig, VncState *local) |
176 | { |
177 | buffer_init(&local->output, "vnc-worker-output" ); |
178 | local->sioc = NULL; /* Don't do any network work on this thread */ |
179 | local->ioc = NULL; /* Don't do any network work on this thread */ |
180 | |
181 | local->vnc_encoding = orig->vnc_encoding; |
182 | local->features = orig->features; |
183 | local->vd = orig->vd; |
184 | local->lossy_rect = orig->lossy_rect; |
185 | local->write_pixels = orig->write_pixels; |
186 | local->client_pf = orig->client_pf; |
187 | local->client_be = orig->client_be; |
188 | local->tight = orig->tight; |
189 | local->zlib = orig->zlib; |
190 | local->hextile = orig->hextile; |
191 | local->zrle = orig->zrle; |
192 | } |
193 | |
194 | static void vnc_async_encoding_end(VncState *orig, VncState *local) |
195 | { |
196 | buffer_free(&local->output); |
197 | orig->tight = local->tight; |
198 | orig->zlib = local->zlib; |
199 | orig->hextile = local->hextile; |
200 | orig->zrle = local->zrle; |
201 | orig->lossy_rect = local->lossy_rect; |
202 | } |
203 | |
204 | static int vnc_worker_thread_loop(VncJobQueue *queue) |
205 | { |
206 | VncJob *job; |
207 | VncRectEntry *entry, *tmp; |
208 | VncState vs = {}; |
209 | int n_rectangles; |
210 | int saved_offset; |
211 | |
212 | vnc_lock_queue(queue); |
213 | while (QTAILQ_EMPTY(&queue->jobs) && !queue->exit) { |
214 | qemu_cond_wait(&queue->cond, &queue->mutex); |
215 | } |
216 | /* Here job can only be NULL if queue->exit is true */ |
217 | job = QTAILQ_FIRST(&queue->jobs); |
218 | vnc_unlock_queue(queue); |
219 | assert(job->vs->magic == VNC_MAGIC); |
220 | |
221 | if (queue->exit) { |
222 | return -1; |
223 | } |
224 | |
225 | vnc_lock_output(job->vs); |
226 | if (job->vs->ioc == NULL || job->vs->abort == true) { |
227 | vnc_unlock_output(job->vs); |
228 | goto disconnected; |
229 | } |
230 | if (buffer_empty(&job->vs->output)) { |
231 | /* |
232 | * Looks like a NOP as it obviously moves no data. But it |
233 | * moves the empty buffer, so we don't have to malloc a new |
234 | * one for vs.output |
235 | */ |
236 | buffer_move_empty(&vs.output, &job->vs->output); |
237 | } |
238 | vnc_unlock_output(job->vs); |
239 | |
240 | /* Make a local copy of vs and switch output buffers */ |
241 | vnc_async_encoding_start(job->vs, &vs); |
242 | vs.magic = VNC_MAGIC; |
243 | |
244 | /* Start sending rectangles */ |
245 | n_rectangles = 0; |
246 | vnc_write_u8(&vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE); |
247 | vnc_write_u8(&vs, 0); |
248 | saved_offset = vs.output.offset; |
249 | vnc_write_u16(&vs, 0); |
250 | |
251 | vnc_lock_display(job->vs->vd); |
252 | QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) { |
253 | int n; |
254 | |
255 | if (job->vs->ioc == NULL) { |
256 | vnc_unlock_display(job->vs->vd); |
257 | /* Copy persistent encoding data */ |
258 | vnc_async_encoding_end(job->vs, &vs); |
259 | goto disconnected; |
260 | } |
261 | |
262 | n = vnc_send_framebuffer_update(&vs, entry->rect.x, entry->rect.y, |
263 | entry->rect.w, entry->rect.h); |
264 | |
265 | if (n >= 0) { |
266 | n_rectangles += n; |
267 | } |
268 | g_free(entry); |
269 | } |
270 | vnc_unlock_display(job->vs->vd); |
271 | |
272 | /* Put n_rectangles at the beginning of the message */ |
273 | vs.output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF; |
274 | vs.output.buffer[saved_offset + 1] = n_rectangles & 0xFF; |
275 | |
276 | vnc_lock_output(job->vs); |
277 | if (job->vs->ioc != NULL) { |
278 | buffer_move(&job->vs->jobs_buffer, &vs.output); |
279 | /* Copy persistent encoding data */ |
280 | vnc_async_encoding_end(job->vs, &vs); |
281 | |
282 | qemu_bh_schedule(job->vs->bh); |
283 | } else { |
284 | buffer_reset(&vs.output); |
285 | /* Copy persistent encoding data */ |
286 | vnc_async_encoding_end(job->vs, &vs); |
287 | } |
288 | vnc_unlock_output(job->vs); |
289 | |
290 | disconnected: |
291 | vnc_lock_queue(queue); |
292 | QTAILQ_REMOVE(&queue->jobs, job, next); |
293 | vnc_unlock_queue(queue); |
294 | qemu_cond_broadcast(&queue->cond); |
295 | g_free(job); |
296 | vs.magic = 0; |
297 | return 0; |
298 | } |
299 | |
300 | static VncJobQueue *vnc_queue_init(void) |
301 | { |
302 | VncJobQueue *queue = g_new0(VncJobQueue, 1); |
303 | |
304 | qemu_cond_init(&queue->cond); |
305 | qemu_mutex_init(&queue->mutex); |
306 | QTAILQ_INIT(&queue->jobs); |
307 | return queue; |
308 | } |
309 | |
310 | static void vnc_queue_clear(VncJobQueue *q) |
311 | { |
312 | qemu_cond_destroy(&queue->cond); |
313 | qemu_mutex_destroy(&queue->mutex); |
314 | g_free(q); |
315 | queue = NULL; /* Unset global queue */ |
316 | } |
317 | |
318 | static void *vnc_worker_thread(void *arg) |
319 | { |
320 | VncJobQueue *queue = arg; |
321 | |
322 | qemu_thread_get_self(&queue->thread); |
323 | |
324 | while (!vnc_worker_thread_loop(queue)) ; |
325 | vnc_queue_clear(queue); |
326 | return NULL; |
327 | } |
328 | |
329 | static bool vnc_worker_thread_running(void) |
330 | { |
331 | return queue; /* Check global queue */ |
332 | } |
333 | |
334 | void vnc_start_worker_thread(void) |
335 | { |
336 | VncJobQueue *q; |
337 | |
338 | if (vnc_worker_thread_running()) |
339 | return ; |
340 | |
341 | q = vnc_queue_init(); |
342 | qemu_thread_create(&q->thread, "vnc_worker" , vnc_worker_thread, q, |
343 | QEMU_THREAD_DETACHED); |
344 | queue = q; /* Set global queue */ |
345 | } |
346 | |