]>
Commit | Line | Data |
---|---|---|
bd023f95 CC |
1 | /* |
2 | * QEMU VNC display driver | |
3 | * | |
4 | * Copyright (C) 2006 Anthony Liguori <[email protected]> | |
5 | * Copyright (C) 2006 Fabrice Bellard | |
6 | * Copyright (C) 2009 Red Hat, Inc | |
7 | * Copyright (C) 2010 Corentin Chary <[email protected]> | |
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 "vnc.h" | |
30 | #include "vnc-jobs.h" | |
31 | ||
32 | /* | |
33 | * Locking: | |
34 | * | |
35 | * There is three levels of locking: | |
36 | * - jobs queue lock: for each operation on the queue (push, pop, isEmpty?) | |
37 | * - VncDisplay global lock: mainly used for framebuffer updates to avoid | |
38 | * screen corruption if the framebuffer is updated | |
39 | * while the worker is doing something. | |
40 | * - VncState::output lock: used to make sure the output buffer is not corrupted | |
41 | * if two threads try to write on it at the same time | |
42 | * | |
43 | * While the VNC worker thread is working, the VncDisplay global lock is hold | |
44 | * to avoid screen corruptions (this does not block vnc_refresh() because it | |
45 | * uses trylock()) but the output lock is not hold because the thread work on | |
46 | * its own output buffer. | |
47 | * When the encoding job is done, the worker thread will hold the output lock | |
48 | * and copy its output buffer in vs->output. | |
49 | */ | |
50 | ||
51 | struct VncJobQueue { | |
52 | QemuCond cond; | |
53 | QemuMutex mutex; | |
54 | QemuThread thread; | |
55 | Buffer buffer; | |
56 | bool exit; | |
57 | QTAILQ_HEAD(, VncJob) jobs; | |
58 | }; | |
59 | ||
60 | typedef struct VncJobQueue VncJobQueue; | |
61 | ||
62 | /* | |
63 | * We use a single global queue, but most of the functions are | |
64 | * already reetrant, so we can easilly add more than one encoding thread | |
65 | */ | |
66 | static VncJobQueue *queue; | |
67 | ||
68 | static void vnc_lock_queue(VncJobQueue *queue) | |
69 | { | |
70 | qemu_mutex_lock(&queue->mutex); | |
71 | } | |
72 | ||
73 | static void vnc_unlock_queue(VncJobQueue *queue) | |
74 | { | |
75 | qemu_mutex_unlock(&queue->mutex); | |
76 | } | |
77 | ||
78 | VncJob *vnc_job_new(VncState *vs) | |
79 | { | |
80 | VncJob *job = qemu_mallocz(sizeof(VncJob)); | |
81 | ||
82 | job->vs = vs; | |
83 | vnc_lock_queue(queue); | |
84 | QLIST_INIT(&job->rectangles); | |
85 | vnc_unlock_queue(queue); | |
86 | return job; | |
87 | } | |
88 | ||
89 | int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h) | |
90 | { | |
91 | VncRectEntry *entry = qemu_mallocz(sizeof(VncRectEntry)); | |
92 | ||
93 | entry->rect.x = x; | |
94 | entry->rect.y = y; | |
95 | entry->rect.w = w; | |
96 | entry->rect.h = h; | |
97 | ||
98 | vnc_lock_queue(queue); | |
99 | QLIST_INSERT_HEAD(&job->rectangles, entry, next); | |
100 | vnc_unlock_queue(queue); | |
101 | return 1; | |
102 | } | |
103 | ||
104 | void vnc_job_push(VncJob *job) | |
105 | { | |
106 | vnc_lock_queue(queue); | |
107 | if (queue->exit || QLIST_EMPTY(&job->rectangles)) { | |
108 | qemu_free(job); | |
109 | } else { | |
110 | QTAILQ_INSERT_TAIL(&queue->jobs, job, next); | |
111 | qemu_cond_broadcast(&queue->cond); | |
112 | } | |
113 | vnc_unlock_queue(queue); | |
114 | } | |
115 | ||
116 | static bool vnc_has_job_locked(VncState *vs) | |
117 | { | |
118 | VncJob *job; | |
119 | ||
120 | QTAILQ_FOREACH(job, &queue->jobs, next) { | |
121 | if (job->vs == vs || !vs) { | |
122 | return true; | |
123 | } | |
124 | } | |
125 | return false; | |
126 | } | |
127 | ||
128 | bool vnc_has_job(VncState *vs) | |
129 | { | |
130 | bool ret; | |
131 | ||
132 | vnc_lock_queue(queue); | |
133 | ret = vnc_has_job_locked(vs); | |
134 | vnc_unlock_queue(queue); | |
135 | return ret; | |
136 | } | |
137 | ||
138 | void vnc_jobs_clear(VncState *vs) | |
139 | { | |
140 | VncJob *job, *tmp; | |
141 | ||
142 | vnc_lock_queue(queue); | |
143 | QTAILQ_FOREACH_SAFE(job, &queue->jobs, next, tmp) { | |
144 | if (job->vs == vs || !vs) { | |
145 | QTAILQ_REMOVE(&queue->jobs, job, next); | |
146 | } | |
147 | } | |
148 | vnc_unlock_queue(queue); | |
149 | } | |
150 | ||
151 | void vnc_jobs_join(VncState *vs) | |
152 | { | |
153 | vnc_lock_queue(queue); | |
154 | while (vnc_has_job_locked(vs)) { | |
155 | qemu_cond_wait(&queue->cond, &queue->mutex); | |
156 | } | |
157 | vnc_unlock_queue(queue); | |
158 | } | |
159 | ||
160 | /* | |
161 | * Copy data for local use | |
162 | */ | |
163 | static void vnc_async_encoding_start(VncState *orig, VncState *local) | |
164 | { | |
165 | local->vnc_encoding = orig->vnc_encoding; | |
166 | local->features = orig->features; | |
167 | local->ds = orig->ds; | |
168 | local->vd = orig->vd; | |
7d964c9d | 169 | local->lossy_rect = orig->lossy_rect; |
bd023f95 CC |
170 | local->write_pixels = orig->write_pixels; |
171 | local->clientds = orig->clientds; | |
172 | local->tight = orig->tight; | |
173 | local->zlib = orig->zlib; | |
174 | local->hextile = orig->hextile; | |
175 | local->output = queue->buffer; | |
176 | local->csock = -1; /* Don't do any network work on this thread */ | |
177 | ||
178 | buffer_reset(&local->output); | |
179 | } | |
180 | ||
181 | static void vnc_async_encoding_end(VncState *orig, VncState *local) | |
182 | { | |
183 | orig->tight = local->tight; | |
184 | orig->zlib = local->zlib; | |
185 | orig->hextile = local->hextile; | |
7d964c9d | 186 | orig->lossy_rect = local->lossy_rect; |
bd023f95 CC |
187 | } |
188 | ||
189 | static int vnc_worker_thread_loop(VncJobQueue *queue) | |
190 | { | |
191 | VncJob *job; | |
192 | VncRectEntry *entry, *tmp; | |
193 | VncState vs; | |
194 | int n_rectangles; | |
195 | int saved_offset; | |
196 | bool flush; | |
197 | ||
198 | vnc_lock_queue(queue); | |
199 | while (QTAILQ_EMPTY(&queue->jobs) && !queue->exit) { | |
200 | qemu_cond_wait(&queue->cond, &queue->mutex); | |
201 | } | |
202 | /* Here job can only be NULL if queue->exit is true */ | |
203 | job = QTAILQ_FIRST(&queue->jobs); | |
204 | vnc_unlock_queue(queue); | |
205 | ||
206 | if (queue->exit) { | |
207 | return -1; | |
208 | } | |
209 | ||
210 | vnc_lock_output(job->vs); | |
211 | if (job->vs->csock == -1 || job->vs->abort == true) { | |
212 | goto disconnected; | |
213 | } | |
214 | vnc_unlock_output(job->vs); | |
215 | ||
216 | /* Make a local copy of vs and switch output buffers */ | |
217 | vnc_async_encoding_start(job->vs, &vs); | |
218 | ||
219 | /* Start sending rectangles */ | |
220 | n_rectangles = 0; | |
221 | vnc_write_u8(&vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE); | |
222 | vnc_write_u8(&vs, 0); | |
223 | saved_offset = vs.output.offset; | |
224 | vnc_write_u16(&vs, 0); | |
225 | ||
226 | vnc_lock_display(job->vs->vd); | |
227 | QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) { | |
228 | int n; | |
229 | ||
230 | if (job->vs->csock == -1) { | |
231 | vnc_unlock_display(job->vs->vd); | |
73eb4c04 CC |
232 | /* output mutex must be locked before going to |
233 | * disconnected: | |
234 | */ | |
235 | vnc_lock_output(job->vs); | |
bd023f95 CC |
236 | goto disconnected; |
237 | } | |
238 | ||
239 | n = vnc_send_framebuffer_update(&vs, entry->rect.x, entry->rect.y, | |
240 | entry->rect.w, entry->rect.h); | |
241 | ||
242 | if (n >= 0) { | |
243 | n_rectangles += n; | |
244 | } | |
245 | qemu_free(entry); | |
246 | } | |
247 | vnc_unlock_display(job->vs->vd); | |
248 | ||
249 | /* Put n_rectangles at the beginning of the message */ | |
250 | vs.output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF; | |
251 | vs.output.buffer[saved_offset + 1] = n_rectangles & 0xFF; | |
252 | ||
253 | /* Switch back buffers */ | |
254 | vnc_lock_output(job->vs); | |
255 | if (job->vs->csock == -1) { | |
256 | goto disconnected; | |
257 | } | |
258 | ||
259 | vnc_write(job->vs, vs.output.buffer, vs.output.offset); | |
260 | ||
261 | disconnected: | |
262 | /* Copy persistent encoding data */ | |
263 | vnc_async_encoding_end(job->vs, &vs); | |
264 | flush = (job->vs->csock != -1 && job->vs->abort != true); | |
265 | vnc_unlock_output(job->vs); | |
266 | ||
267 | if (flush) { | |
268 | vnc_flush(job->vs); | |
269 | } | |
270 | ||
271 | vnc_lock_queue(queue); | |
272 | QTAILQ_REMOVE(&queue->jobs, job, next); | |
273 | vnc_unlock_queue(queue); | |
274 | qemu_cond_broadcast(&queue->cond); | |
275 | qemu_free(job); | |
276 | return 0; | |
277 | } | |
278 | ||
279 | static VncJobQueue *vnc_queue_init(void) | |
280 | { | |
281 | VncJobQueue *queue = qemu_mallocz(sizeof(VncJobQueue)); | |
282 | ||
283 | qemu_cond_init(&queue->cond); | |
284 | qemu_mutex_init(&queue->mutex); | |
285 | QTAILQ_INIT(&queue->jobs); | |
286 | return queue; | |
287 | } | |
288 | ||
289 | static void vnc_queue_clear(VncJobQueue *q) | |
290 | { | |
291 | qemu_cond_destroy(&queue->cond); | |
292 | qemu_mutex_destroy(&queue->mutex); | |
293 | buffer_free(&queue->buffer); | |
294 | qemu_free(q); | |
295 | queue = NULL; /* Unset global queue */ | |
296 | } | |
297 | ||
298 | static void *vnc_worker_thread(void *arg) | |
299 | { | |
300 | VncJobQueue *queue = arg; | |
301 | ||
302 | qemu_thread_self(&queue->thread); | |
303 | ||
304 | while (!vnc_worker_thread_loop(queue)) ; | |
305 | vnc_queue_clear(queue); | |
306 | return NULL; | |
307 | } | |
308 | ||
309 | void vnc_start_worker_thread(void) | |
310 | { | |
311 | VncJobQueue *q; | |
312 | ||
313 | if (vnc_worker_thread_running()) | |
314 | return ; | |
315 | ||
316 | q = vnc_queue_init(); | |
317 | qemu_thread_create(&q->thread, vnc_worker_thread, q); | |
318 | queue = q; /* Set global queue */ | |
319 | } | |
320 | ||
321 | bool vnc_worker_thread_running(void) | |
322 | { | |
323 | return queue; /* Check global queue */ | |
324 | } | |
325 | ||
326 | void vnc_stop_worker_thread(void) | |
327 | { | |
328 | if (!vnc_worker_thread_running()) | |
329 | return ; | |
330 | ||
331 | /* Remove all jobs and wake up the thread */ | |
332 | vnc_lock_queue(queue); | |
333 | queue->exit = true; | |
334 | vnc_unlock_queue(queue); | |
335 | vnc_jobs_clear(NULL); | |
336 | qemu_cond_broadcast(&queue->cond); | |
337 | } |