2010-07-07 22:58:02 +04:00
|
|
|
/*
|
|
|
|
* QEMU VNC display driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006 Anthony Liguori <anthony@codemonkey.ws>
|
|
|
|
* Copyright (C) 2006 Fabrice Bellard
|
|
|
|
* Copyright (C) 2009 Red Hat, Inc
|
|
|
|
* Copyright (C) 2010 Corentin Chary <corentin.chary@gmail.com>
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
|
|
* in the Software without restriction, including without limitation the rights
|
|
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
|
|
* furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
* THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include "vnc.h"
|
|
|
|
#include "vnc-jobs.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/sockets.h"
|
2015-03-17 20:16:21 +03:00
|
|
|
#include "block/aio.h"
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Locking:
|
|
|
|
*
|
2012-10-18 20:40:53 +04:00
|
|
|
* There are three levels of locking:
|
2010-07-07 22:58:02 +04:00
|
|
|
* - jobs queue lock: for each operation on the queue (push, pop, isEmpty?)
|
|
|
|
* - VncDisplay global lock: mainly used for framebuffer updates to avoid
|
|
|
|
* screen corruption if the framebuffer is updated
|
2012-10-18 20:40:53 +04:00
|
|
|
* while the worker is doing something.
|
2010-07-07 22:58:02 +04:00
|
|
|
* - VncState::output lock: used to make sure the output buffer is not corrupted
|
2012-10-18 20:40:53 +04:00
|
|
|
* if two threads try to write on it at the same time
|
2010-07-07 22:58:02 +04:00
|
|
|
*
|
2012-10-18 20:40:53 +04:00
|
|
|
* While the VNC worker thread is working, the VncDisplay global lock is held
|
|
|
|
* to avoid screen corruption (this does not block vnc_refresh() because it
|
|
|
|
* uses trylock()) but the output lock is not held because the thread works on
|
2010-07-07 22:58:02 +04:00
|
|
|
* its own output buffer.
|
|
|
|
* When the encoding job is done, the worker thread will hold the output lock
|
|
|
|
* and copy its output buffer in vs->output.
|
2012-10-18 20:40:53 +04:00
|
|
|
*/
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
struct VncJobQueue {
|
|
|
|
QemuCond cond;
|
|
|
|
QemuMutex mutex;
|
|
|
|
QemuThread thread;
|
|
|
|
Buffer buffer;
|
|
|
|
bool exit;
|
|
|
|
QTAILQ_HEAD(, VncJob) jobs;
|
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct VncJobQueue VncJobQueue;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We use a single global queue, but most of the functions are
|
2012-10-18 20:40:53 +04:00
|
|
|
* already reentrant, so we can easily add more than one encoding thread
|
2010-07-07 22:58:02 +04:00
|
|
|
*/
|
|
|
|
static VncJobQueue *queue;
|
|
|
|
|
|
|
|
static void vnc_lock_queue(VncJobQueue *queue)
|
|
|
|
{
|
|
|
|
qemu_mutex_lock(&queue->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_unlock_queue(VncJobQueue *queue)
|
|
|
|
{
|
|
|
|
qemu_mutex_unlock(&queue->mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
VncJob *vnc_job_new(VncState *vs)
|
|
|
|
{
|
2015-11-03 19:12:03 +03:00
|
|
|
VncJob *job = g_new0(VncJob, 1);
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
job->vs = vs;
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
QLIST_INIT(&job->rectangles);
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
return job;
|
|
|
|
}
|
|
|
|
|
|
|
|
int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h)
|
|
|
|
{
|
2015-11-03 19:12:03 +03:00
|
|
|
VncRectEntry *entry = g_new0(VncRectEntry, 1);
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
entry->rect.x = x;
|
|
|
|
entry->rect.y = y;
|
|
|
|
entry->rect.w = w;
|
|
|
|
entry->rect.h = h;
|
|
|
|
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
QLIST_INSERT_HEAD(&job->rectangles, entry, next);
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vnc_job_push(VncJob *job)
|
|
|
|
{
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
if (queue->exit || QLIST_EMPTY(&job->rectangles)) {
|
2011-08-21 07:09:37 +04:00
|
|
|
g_free(job);
|
2010-07-07 22:58:02 +04:00
|
|
|
} else {
|
|
|
|
QTAILQ_INSERT_TAIL(&queue->jobs, job, next);
|
|
|
|
qemu_cond_broadcast(&queue->cond);
|
|
|
|
}
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vnc_has_job_locked(VncState *vs)
|
|
|
|
{
|
|
|
|
VncJob *job;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH(job, &queue->jobs, next) {
|
|
|
|
if (job->vs == vs || !vs) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool vnc_has_job(VncState *vs)
|
|
|
|
{
|
|
|
|
bool ret;
|
|
|
|
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
ret = vnc_has_job_locked(vs);
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vnc_jobs_clear(VncState *vs)
|
|
|
|
{
|
|
|
|
VncJob *job, *tmp;
|
|
|
|
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
QTAILQ_FOREACH_SAFE(job, &queue->jobs, next, tmp) {
|
|
|
|
if (job->vs == vs || !vs) {
|
|
|
|
QTAILQ_REMOVE(&queue->jobs, job, next);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vnc_jobs_join(VncState *vs)
|
|
|
|
{
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
while (vnc_has_job_locked(vs)) {
|
|
|
|
qemu_cond_wait(&queue->cond, &queue->mutex);
|
|
|
|
}
|
|
|
|
vnc_unlock_queue(queue);
|
2012-03-14 10:58:47 +04:00
|
|
|
vnc_jobs_consume_buffer(vs);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vnc_jobs_consume_buffer(VncState *vs)
|
|
|
|
{
|
|
|
|
bool flush;
|
|
|
|
|
|
|
|
vnc_lock_output(vs);
|
|
|
|
if (vs->jobs_buffer.offset) {
|
|
|
|
vnc_write(vs, vs->jobs_buffer.buffer, vs->jobs_buffer.offset);
|
|
|
|
buffer_reset(&vs->jobs_buffer);
|
|
|
|
}
|
|
|
|
flush = vs->csock != -1 && vs->abort != true;
|
|
|
|
vnc_unlock_output(vs);
|
|
|
|
|
|
|
|
if (flush) {
|
|
|
|
vnc_flush(vs);
|
|
|
|
}
|
2010-07-07 22:58:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy data for local use
|
|
|
|
*/
|
|
|
|
static void vnc_async_encoding_start(VncState *orig, VncState *local)
|
|
|
|
{
|
|
|
|
local->vnc_encoding = orig->vnc_encoding;
|
|
|
|
local->features = orig->features;
|
|
|
|
local->vd = orig->vd;
|
2011-02-04 11:05:56 +03:00
|
|
|
local->lossy_rect = orig->lossy_rect;
|
2010-07-07 22:58:02 +04:00
|
|
|
local->write_pixels = orig->write_pixels;
|
2012-10-10 15:29:43 +04:00
|
|
|
local->client_pf = orig->client_pf;
|
|
|
|
local->client_be = orig->client_be;
|
2010-07-07 22:58:02 +04:00
|
|
|
local->tight = orig->tight;
|
|
|
|
local->zlib = orig->zlib;
|
|
|
|
local->hextile = orig->hextile;
|
2011-02-04 11:06:01 +03:00
|
|
|
local->zrle = orig->zrle;
|
2010-07-07 22:58:02 +04:00
|
|
|
local->output = queue->buffer;
|
|
|
|
local->csock = -1; /* Don't do any network work on this thread */
|
|
|
|
|
|
|
|
buffer_reset(&local->output);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_async_encoding_end(VncState *orig, VncState *local)
|
|
|
|
{
|
|
|
|
orig->tight = local->tight;
|
|
|
|
orig->zlib = local->zlib;
|
|
|
|
orig->hextile = local->hextile;
|
2011-02-04 11:06:01 +03:00
|
|
|
orig->zrle = local->zrle;
|
2011-02-04 11:05:56 +03:00
|
|
|
orig->lossy_rect = local->lossy_rect;
|
2011-02-26 00:54:53 +03:00
|
|
|
|
|
|
|
queue->buffer = local->output;
|
2010-07-07 22:58:02 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int vnc_worker_thread_loop(VncJobQueue *queue)
|
|
|
|
{
|
|
|
|
VncJob *job;
|
|
|
|
VncRectEntry *entry, *tmp;
|
|
|
|
VncState vs;
|
|
|
|
int n_rectangles;
|
|
|
|
int saved_offset;
|
|
|
|
|
|
|
|
vnc_lock_queue(queue);
|
|
|
|
while (QTAILQ_EMPTY(&queue->jobs) && !queue->exit) {
|
|
|
|
qemu_cond_wait(&queue->cond, &queue->mutex);
|
|
|
|
}
|
|
|
|
/* Here job can only be NULL if queue->exit is true */
|
|
|
|
job = QTAILQ_FIRST(&queue->jobs);
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
|
|
|
|
if (queue->exit) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
vnc_lock_output(job->vs);
|
|
|
|
if (job->vs->csock == -1 || job->vs->abort == true) {
|
2012-03-14 10:58:47 +04:00
|
|
|
vnc_unlock_output(job->vs);
|
2010-07-07 22:58:02 +04:00
|
|
|
goto disconnected;
|
|
|
|
}
|
|
|
|
vnc_unlock_output(job->vs);
|
|
|
|
|
|
|
|
/* Make a local copy of vs and switch output buffers */
|
|
|
|
vnc_async_encoding_start(job->vs, &vs);
|
|
|
|
|
|
|
|
/* Start sending rectangles */
|
|
|
|
n_rectangles = 0;
|
|
|
|
vnc_write_u8(&vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
|
|
|
|
vnc_write_u8(&vs, 0);
|
|
|
|
saved_offset = vs.output.offset;
|
|
|
|
vnc_write_u16(&vs, 0);
|
|
|
|
|
|
|
|
vnc_lock_display(job->vs->vd);
|
|
|
|
QLIST_FOREACH_SAFE(entry, &job->rectangles, next, tmp) {
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (job->vs->csock == -1) {
|
|
|
|
vnc_unlock_display(job->vs->vd);
|
vnc: Fix qemu crashed when vnc client disconnect suddenly
Hi,
When I use RealVNC viewer client (http://www.realvnc.com/) to connect vnc server,
the client disconnect suddenly, and I click reconnect button immediately, then the Qemu crashed.
In the function vnc_worker_thread_loop, will call vnc_async_encoding_start
to set the local vs->output buffer by global queue's buffer. Then send rectangles to
the vnc client call function vnc_send_framebuffer_update. Finally, Under normal circumstances,
call vnc_async_encoding_end to set the global queue'buffer by the local vs->output conversely.
When the vnc client disconnect, the job->vs->csock will be set to -1. And the current prcoess
logic will goto disconnected partion without call function vnc_async_encoding_end.
But, the function vnc_send_framebuffer_update will call buffer_reserve, which
maybe call g_realloc reset the local vs's buffer, meaning the global queue's buffer is modified also.
If anyone use the original global queue's buffer memory will cause corruption and then crash qemu.
This patch assure the function vnc_async_encoding_end being called
even though the vnc client disconnect suddenly.
Signed-off-by: Gonglei <arei.gonglei@huawei.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2014-01-23 17:30:57 +04:00
|
|
|
/* Copy persistent encoding data */
|
|
|
|
vnc_async_encoding_end(job->vs, &vs);
|
2010-07-07 22:58:02 +04:00
|
|
|
goto disconnected;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = vnc_send_framebuffer_update(&vs, entry->rect.x, entry->rect.y,
|
|
|
|
entry->rect.w, entry->rect.h);
|
|
|
|
|
|
|
|
if (n >= 0) {
|
|
|
|
n_rectangles += n;
|
|
|
|
}
|
2011-08-21 07:09:37 +04:00
|
|
|
g_free(entry);
|
2010-07-07 22:58:02 +04:00
|
|
|
}
|
|
|
|
vnc_unlock_display(job->vs->vd);
|
|
|
|
|
|
|
|
/* Put n_rectangles at the beginning of the message */
|
|
|
|
vs.output.buffer[saved_offset] = (n_rectangles >> 8) & 0xFF;
|
|
|
|
vs.output.buffer[saved_offset + 1] = n_rectangles & 0xFF;
|
|
|
|
|
|
|
|
vnc_lock_output(job->vs);
|
2012-03-14 10:58:47 +04:00
|
|
|
if (job->vs->csock != -1) {
|
|
|
|
buffer_reserve(&job->vs->jobs_buffer, vs.output.offset);
|
|
|
|
buffer_append(&job->vs->jobs_buffer, vs.output.buffer,
|
|
|
|
vs.output.offset);
|
|
|
|
/* Copy persistent encoding data */
|
|
|
|
vnc_async_encoding_end(job->vs, &vs);
|
|
|
|
|
|
|
|
qemu_bh_schedule(job->vs->bh);
|
vnc: Fix qemu crashed when vnc client disconnect suddenly
Hi,
When I use RealVNC viewer client (http://www.realvnc.com/) to connect vnc server,
the client disconnect suddenly, and I click reconnect button immediately, then the Qemu crashed.
In the function vnc_worker_thread_loop, will call vnc_async_encoding_start
to set the local vs->output buffer by global queue's buffer. Then send rectangles to
the vnc client call function vnc_send_framebuffer_update. Finally, Under normal circumstances,
call vnc_async_encoding_end to set the global queue'buffer by the local vs->output conversely.
When the vnc client disconnect, the job->vs->csock will be set to -1. And the current prcoess
logic will goto disconnected partion without call function vnc_async_encoding_end.
But, the function vnc_send_framebuffer_update will call buffer_reserve, which
maybe call g_realloc reset the local vs's buffer, meaning the global queue's buffer is modified also.
If anyone use the original global queue's buffer memory will cause corruption and then crash qemu.
This patch assure the function vnc_async_encoding_end being called
even though the vnc client disconnect suddenly.
Signed-off-by: Gonglei <arei.gonglei@huawei.com>
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2014-01-23 17:30:57 +04:00
|
|
|
} else {
|
|
|
|
/* Copy persistent encoding data */
|
|
|
|
vnc_async_encoding_end(job->vs, &vs);
|
2010-07-07 22:58:02 +04:00
|
|
|
}
|
|
|
|
vnc_unlock_output(job->vs);
|
|
|
|
|
2012-03-14 10:58:47 +04:00
|
|
|
disconnected:
|
2010-07-07 22:58:02 +04:00
|
|
|
vnc_lock_queue(queue);
|
|
|
|
QTAILQ_REMOVE(&queue->jobs, job, next);
|
|
|
|
vnc_unlock_queue(queue);
|
|
|
|
qemu_cond_broadcast(&queue->cond);
|
2011-08-21 07:09:37 +04:00
|
|
|
g_free(job);
|
2010-07-07 22:58:02 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static VncJobQueue *vnc_queue_init(void)
|
|
|
|
{
|
2015-11-03 19:12:03 +03:00
|
|
|
VncJobQueue *queue = g_new0(VncJobQueue, 1);
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
qemu_cond_init(&queue->cond);
|
|
|
|
qemu_mutex_init(&queue->mutex);
|
|
|
|
QTAILQ_INIT(&queue->jobs);
|
|
|
|
return queue;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vnc_queue_clear(VncJobQueue *q)
|
|
|
|
{
|
|
|
|
qemu_cond_destroy(&queue->cond);
|
|
|
|
qemu_mutex_destroy(&queue->mutex);
|
|
|
|
buffer_free(&queue->buffer);
|
2011-08-21 07:09:37 +04:00
|
|
|
g_free(q);
|
2010-07-07 22:58:02 +04:00
|
|
|
queue = NULL; /* Unset global queue */
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *vnc_worker_thread(void *arg)
|
|
|
|
{
|
|
|
|
VncJobQueue *queue = arg;
|
|
|
|
|
2011-03-12 19:43:51 +03:00
|
|
|
qemu_thread_get_self(&queue->thread);
|
2010-07-07 22:58:02 +04:00
|
|
|
|
|
|
|
while (!vnc_worker_thread_loop(queue)) ;
|
|
|
|
vnc_queue_clear(queue);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-10-28 15:04:48 +04:00
|
|
|
static bool vnc_worker_thread_running(void)
|
|
|
|
{
|
|
|
|
return queue; /* Check global queue */
|
|
|
|
}
|
|
|
|
|
2010-07-07 22:58:02 +04:00
|
|
|
void vnc_start_worker_thread(void)
|
|
|
|
{
|
|
|
|
VncJobQueue *q;
|
|
|
|
|
|
|
|
if (vnc_worker_thread_running())
|
|
|
|
return ;
|
|
|
|
|
|
|
|
q = vnc_queue_init();
|
2014-01-30 14:20:32 +04:00
|
|
|
qemu_thread_create(&q->thread, "vnc_worker", vnc_worker_thread, q,
|
|
|
|
QEMU_THREAD_DETACHED);
|
2010-07-07 22:58:02 +04:00
|
|
|
queue = q; /* Set global queue */
|
|
|
|
}
|