vnc: threaded VNC server (bd023f95) · Commits · SUMMER2020 / students / proj-2021291

Makefile.objs

+6 −1

Original line number	Diff line number	Diff line
		@@ -111,10 +111,15 @@ ui-obj-y += vnc-enc-tight.o vnc-palette.o
		ui-obj-$(CONFIG_VNC_TLS) += vnc-tls.o vnc-auth-vencrypt.o
		ui-obj-$(CONFIG_VNC_SASL) += vnc-auth-sasl.o
		ui-obj-$(CONFIG_COCOA) += cocoa.o
		ifdef CONFIG_VNC_THREAD
		ui-obj-y += vnc-jobs-async.o
		else
		ui-obj-y += vnc-jobs-sync.o
		endif
		common-obj-y += $(addprefix ui/, $(ui-obj-y))

		common-obj-y += iov.o acl.o
		common-obj-$(CONFIG_IOTHREAD) += qemu-thread.o
		common-obj-$(CONFIG_THREAD) += qemu-thread.o
		common-obj-y += notify.o event_notifier.o
		common-obj-y += qemu-timer.o

configure

+13 −0

Original line number	Diff line number	Diff line
		@@ -270,6 +270,7 @@ vnc_tls=""
		vnc_sasl=""
		vnc_jpeg=""
		vnc_png=""
		vnc_thread=""
		xen=""
		linux_aio=""
		attr=""
		@@ -585,6 +586,10 @@ for opt do
		;;
		--enable-vnc-png) vnc_png="yes"
		;;
		--disable-vnc-thread) vnc_thread="no"
		;;
		--enable-vnc-thread) vnc_thread="yes"
		;;
		--disable-slirp) slirp="no"
		;;
		--disable-uuid) uuid="no"
		@@ -839,6 +844,8 @@ echo " --disable-vnc-jpeg disable JPEG lossy compression for VNC server"
		echo " --enable-vnc-jpeg enable JPEG lossy compression for VNC server"
		echo " --disable-vnc-png disable PNG compression for VNC server"
		echo " --enable-vnc-png enable PNG compression for VNC server"
		echo " --disable-vnc-thread disable threaded VNC server"
		echo " --enable-vnc-thread enable threaded VNC server"
		echo " --disable-curses disable curses output"
		echo " --enable-curses enable curses output"
		echo " --disable-curl disable curl connectivity"
		@@ -2156,6 +2163,7 @@ echo "VNC TLS support $vnc_tls"
		echo "VNC SASL support $vnc_sasl"
		echo "VNC JPEG support $vnc_jpeg"
		echo "VNC PNG support $vnc_png"
		echo "VNC thread $vnc_thread"
		if test -n "$sparc_cpu"; then
		echo "Target Sparc Arch $sparc_cpu"
		fi
		@@ -2301,6 +2309,10 @@ if test "$vnc_png" = "yes" ; then
		echo "CONFIG_VNC_PNG=y" >> $config_host_mak
		echo "VNC_PNG_CFLAGS=$vnc_png_cflags" >> $config_host_mak
		fi
		if test "$vnc_thread" = "yes" ; then
		echo "CONFIG_VNC_THREAD=y" >> $config_host_mak
		echo "CONFIG_THREAD=y" >> $config_host_mak
		fi
		if test "$fnmatch" = "yes" ; then
		echo "CONFIG_FNMATCH=y" >> $config_host_mak
		fi
		@@ -2377,6 +2389,7 @@ if test "$xen" = "yes" ; then
		fi
		if test "$io_thread" = "yes" ; then
		echo "CONFIG_IOTHREAD=y" >> $config_host_mak
		echo "CONFIG_THREAD=y" >> $config_host_mak
		fi
		if test "$linux_aio" = "yes" ; then
		echo "CONFIG_LINUX_AIO=y" >> $config_host_mak

ui/vnc-jobs-async.c

0 → 100644

+331 −0

Original line number	Diff line number	Diff line
		/*
		* 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"

		/*
		* Locking:
		*
		* There is three levels of locking:
		* - 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
		* while the worker is doing something.
		* - VncState::output lock: used to make sure the output buffer is not corrupted
		* if two threads try to write on it at the same time
		*
		* While the VNC worker thread is working, the VncDisplay global lock is hold
		* to avoid screen corruptions (this does not block vnc_refresh() because it
		* uses trylock()) but the output lock is not hold because the thread work on
		* 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.
		*/

		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
		* already reetrant, so we can easilly add more than one encoding thread
		*/
		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)
		{
		VncJob *job = qemu_mallocz(sizeof(VncJob));

		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)
		{
		VncRectEntry *entry = qemu_mallocz(sizeof(VncRectEntry));

		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)) {
		qemu_free(job);
		} 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);
		}

		/*
		* 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->ds = orig->ds;
		local->vd = orig->vd;
		local->write_pixels = orig->write_pixels;
		local->clientds = orig->clientds;
		local->tight = orig->tight;
		local->zlib = orig->zlib;
		local->hextile = orig->hextile;
		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;
		}

		static int vnc_worker_thread_loop(VncJobQueue *queue)
		{
		VncJob *job;
		VncRectEntry entry, tmp;
		VncState vs;
		int n_rectangles;
		int saved_offset;
		bool flush;

		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) {
		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);
		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;
		}
		qemu_free(entry);
		}
		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;

		/* Switch back buffers */
		vnc_lock_output(job->vs);
		if (job->vs->csock == -1) {
		goto disconnected;
		}

		vnc_write(job->vs, vs.output.buffer, vs.output.offset);

		disconnected:
		/* Copy persistent encoding data */
		vnc_async_encoding_end(job->vs, &vs);
		flush = (job->vs->csock != -1 && job->vs->abort != true);
		vnc_unlock_output(job->vs);

		if (flush) {
		vnc_flush(job->vs);
		}

		vnc_lock_queue(queue);
		QTAILQ_REMOVE(&queue->jobs, job, next);
		vnc_unlock_queue(queue);
		qemu_cond_broadcast(&queue->cond);
		qemu_free(job);
		return 0;
		}

		static VncJobQueue *vnc_queue_init(void)
		{
		VncJobQueue *queue = qemu_mallocz(sizeof(VncJobQueue));

		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);
		qemu_free(q);
		queue = NULL; /* Unset global queue */
		}

		static void vnc_worker_thread(void arg)
		{
		VncJobQueue *queue = arg;

		qemu_thread_self(&queue->thread);

		while (!vnc_worker_thread_loop(queue)) ;
		vnc_queue_clear(queue);
		return NULL;
		}

		void vnc_start_worker_thread(void)
		{
		VncJobQueue *q;

		if (vnc_worker_thread_running())
		return ;

		q = vnc_queue_init();
		qemu_thread_create(&q->thread, vnc_worker_thread, q);
		queue = q; /* Set global queue */
		}

		bool vnc_worker_thread_running(void)
		{
		return queue; /* Check global queue */
		}

		void vnc_stop_worker_thread(void)
		{
		if (!vnc_worker_thread_running())
		return ;

		/* Remove all jobs and wake up the thread */
		vnc_lock_queue(queue);
		queue->exit = true;
		vnc_unlock_queue(queue);
		vnc_jobs_clear(NULL);
		qemu_cond_broadcast(&queue->cond);
		}

ui/vnc-jobs-sync.c

0 → 100644

+73 −0

Original line number	Diff line number	Diff line
		/*
		* 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"

		void vnc_jobs_clear(VncState *vs)
		{
		}

		void vnc_jobs_join(VncState *vs)
		{
		}

		VncJob vnc_job_new(VncState vs)
		{
		vs->job.vs = vs;
		vs->job.rectangles = 0;

		vnc_write_u8(vs, VNC_MSG_SERVER_FRAMEBUFFER_UPDATE);
		vnc_write_u8(vs, 0);
		vs->job.saved_offset = vs->output.offset;
		vnc_write_u16(vs, 0);
		return &vs->job;
		}

		void vnc_job_push(VncJob *job)
		{
		VncState *vs = job->vs;

		vs->output.buffer[job->saved_offset] = (job->rectangles >> 8) & 0xFF;
		vs->output.buffer[job->saved_offset + 1] = job->rectangles & 0xFF;
		vnc_flush(job->vs);
		}

		int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h)
		{
		int n;

		n = vnc_send_framebuffer_update(job->vs, x, y, w, h);
		if (n >= 0)
		job->rectangles += n;
		return n;
		}

		bool vnc_has_job(VncState *vs)
		{
		return false;
		}

ui/vnc-jobs.h

0 → 100644

+87 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU VNC display driver
		*
		* From libvncserver/rfb/rfbproto.h
		* Copyright (C) 2005 Rohit Kumar, Johannes E. Schindelin
		* Copyright (C) 2000-2002 Constantin Kaplinsky. All Rights Reserved.
		* Copyright (C) 2000 Tridia Corporation. All Rights Reserved.
		* Copyright (C) 1999 AT&T Laboratories Cambridge. All Rights Reserved.
		*
		*
		* 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.
		*/

		#ifndef VNC_JOBS_H
		#define VNC_JOBS_H

		/* Jobs */
		VncJob vnc_job_new(VncState vs);
		int vnc_job_add_rect(VncJob *job, int x, int y, int w, int h);
		void vnc_job_push(VncJob *job);
		bool vnc_has_job(VncState *vs);
		void vnc_jobs_clear(VncState *vs);
		void vnc_jobs_join(VncState *vs);

		#ifdef CONFIG_VNC_THREAD

		void vnc_start_worker_thread(void);
		bool vnc_worker_thread_running(void);
		void vnc_stop_worker_thread(void);

		#endif /* CONFIG_VNC_THREAD */

		/* Locks */
		static inline int vnc_trylock_display(VncDisplay *vd)
		{
		#ifdef CONFIG_VNC_THREAD
		return qemu_mutex_trylock(&vd->mutex);
		#else
		return 0;
		#endif
		}

		static inline void vnc_lock_display(VncDisplay *vd)
		{
		#ifdef CONFIG_VNC_THREAD
		qemu_mutex_lock(&vd->mutex);
		#endif
		}

		static inline void vnc_unlock_display(VncDisplay *vd)
		{
		#ifdef CONFIG_VNC_THREAD
		qemu_mutex_unlock(&vd->mutex);
		#endif
		}

		static inline void vnc_lock_output(VncState *vs)
		{
		#ifdef CONFIG_VNC_THREAD
		qemu_mutex_lock(&vs->output_mutex);
		#endif
		}

		static inline void vnc_unlock_output(VncState *vs)
		{
		#ifdef CONFIG_VNC_THREAD
		qemu_mutex_unlock(&vs->output_mutex);
		#endif
		}

		#endif /* VNC_JOBS_H */