Merge remote-tracking branch 'remotes/kraxel/tags/pull-vnc-20151116-1' into staging (c27e9014) · Commits · SUMMER2020 / students / proj-2021291

include/qemu/buffer.h

+43 −0

Original line number	Diff line number	Diff line
		@@ -34,11 +34,34 @@ typedef struct Buffer Buffer;
		*/

		struct Buffer {
		char *name;
		size_t capacity;
		size_t offset;
		uint64_t avg_size;
		uint8_t *buffer;
		};

		/**
		* buffer_init:
		* @buffer: the buffer object
		* @name: buffer name
		*
		* Optionally attach a name to the buffer, to make it easier
		* to identify in debug traces.
		*/
		void buffer_init(Buffer buffer, const char name, ...)
		GCC_FMT_ATTR(2, 3);

		/**
		* buffer_shrink:
		* @buffer: the buffer object
		*
		* Try to shrink the buffer. Checks current buffer capacity and size
		* and reduces capacity in case only a fraction of the buffer is
		* actually used.
		*/
		void buffer_shrink(Buffer *buffer);

		/**
		* buffer_reserve:
		* @buffer: the buffer object
		@@ -115,4 +138,24 @@ uint8_t buffer_end(Buffer buffer);
		*/
		gboolean buffer_empty(Buffer *buffer);

		/**
		* buffer_move_empty:
		* @to: destination buffer object
		* @from: source buffer object
		*
		* Moves buffer, without copying data. 'to' buffer must be empty.
		* 'from' buffer is empty and zero-sized on return.
		*/
		void buffer_move_empty(Buffer to, Buffer from);

		/**
		* buffer_move:
		* @to: destination buffer object
		* @from: source buffer object
		*
		* Moves buffer, copying data (unless 'to' buffer happens to be empty).
		* 'from' buffer is empty and zero-sized on return.
		*/
		void buffer_move(Buffer to, Buffer from);

		#endif /* QEMU_BUFFER_H__ */

trace-events

+6 −0

Original line number	Diff line number	Diff line
		@@ -1419,6 +1419,12 @@ ppc_tb_adjust(uint64_t offs1, uint64_t offs2, int64_t diff, int64_t seconds) "ad
		prep_io_800_writeb(uint32_t addr, uint32_t val) "0x%08" PRIx32 " => 0x%02" PRIx32
		prep_io_800_readb(uint32_t addr, uint32_t retval) "0x%08" PRIx32 " <= 0x%02" PRIx32

		# io/buffer.c
		buffer_resize(const char *buf, size_t olen, size_t len) "%s: old %zd, new %zd"
		buffer_move_empty(const char buf, size_t len, const char from) "%s: %zd bytes from %s"
		buffer_move(const char buf, size_t len, const char from) "%s: %zd bytes from %s"
		buffer_free(const char *buf, size_t len) "%s: capacity %zd"

		# util/hbitmap.c
		hbitmap_iter_skip_words(const void hb, void hbi, uint64_t pos, unsigned long cur) "hb %p hbi %p pos %"PRId64" cur 0x%lx"
		hbitmap_reset(void *hb, uint64_t start, uint64_t count, uint64_t sbit, uint64_t ebit) "hb %p items %"PRIu64",%"PRIu64" bits %"PRIu64"..%"PRIu64

ui/vnc-jobs.c

+20 −14

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include "vnc.h"
		#include "vnc-jobs.h"
		#include "qemu/sockets.h"
		#include "qemu/main-loop.h"
		#include "block/aio.h"

		/*
		@@ -54,7 +55,6 @@ struct VncJobQueue {
		QemuCond cond;
		QemuMutex mutex;
		QemuThread thread;
		Buffer buffer;
		bool exit;
		QTAILQ_HEAD(, VncJob) jobs;
		};
		@@ -166,8 +166,11 @@ void vnc_jobs_consume_buffer(VncState *vs)

		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);
		if (vs->csock != -1 && buffer_empty(&vs->output)) {
		qemu_set_fd_handler(vs->csock, vnc_client_read,
		vnc_client_write, vs);
		}
		buffer_move(&vs->output, &vs->jobs_buffer);
		}
		flush = vs->csock != -1 && vs->abort != true;
		vnc_unlock_output(vs);
		@@ -182,6 +185,9 @@ void vnc_jobs_consume_buffer(VncState *vs)
		*/
		static void vnc_async_encoding_start(VncState orig, VncState local)
		{
		buffer_init(&local->output, "vnc-worker-output");
		local->csock = -1; /* Don't do any network work on this thread */

		local->vnc_encoding = orig->vnc_encoding;
		local->features = orig->features;
		local->vd = orig->vd;
		@@ -193,10 +199,6 @@ static void vnc_async_encoding_start(VncState orig, VncState local)
		local->zlib = orig->zlib;
		local->hextile = orig->hextile;
		local->zrle = orig->zrle;
		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)
		@@ -206,15 +208,13 @@ static void vnc_async_encoding_end(VncState orig, VncState local)
		orig->hextile = local->hextile;
		orig->zrle = local->zrle;
		orig->lossy_rect = local->lossy_rect;

		queue->buffer = local->output;
		}

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

		@@ -235,6 +235,14 @@ static int vnc_worker_thread_loop(VncJobQueue *queue)
		vnc_unlock_output(job->vs);
		goto disconnected;
		}
		if (buffer_empty(&job->vs->output)) {
		/*
		* Looks like a NOP as it obviously moves no data. But it
		* moves the empty buffer, so we don't have to malloc a new
		* one for vs.output
		*/
		buffer_move_empty(&vs.output, &job->vs->output);
		}
		vnc_unlock_output(job->vs);

		/* Make a local copy of vs and switch output buffers */
		@@ -274,14 +282,13 @@ static int vnc_worker_thread_loop(VncJobQueue *queue)

		vnc_lock_output(job->vs);
		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);
		buffer_move(&job->vs->jobs_buffer, &vs.output);
		/* Copy persistent encoding data */
		vnc_async_encoding_end(job->vs, &vs);

		qemu_bh_schedule(job->vs->bh);
		} else {
		buffer_reset(&vs.output);
		/* Copy persistent encoding data */
		vnc_async_encoding_end(job->vs, &vs);
		}
		@@ -310,7 +317,6 @@ static void vnc_queue_clear(VncJobQueue *q)
		{
		qemu_cond_destroy(&queue->cond);
		qemu_mutex_destroy(&queue->mutex);
		buffer_free(&queue->buffer);
		g_free(q);
		queue = NULL; /* Unset global queue */
		}

ui/vnc.c

+68 −24

Original line number	Diff line number	Diff line
		@@ -615,10 +615,25 @@ static void framebuffer_update_request(VncState *vs, int incremental,
		static void vnc_refresh(DisplayChangeListener *dcl);
		static int vnc_refresh_server_surface(VncDisplay *vd);

		static int vnc_width(VncDisplay *vd)
		{
		return MIN(VNC_MAX_WIDTH, ROUND_UP(surface_width(vd->ds),
		VNC_DIRTY_PIXELS_PER_BIT));
		}

		static int vnc_height(VncDisplay *vd)
		{
		return MIN(VNC_MAX_HEIGHT, surface_height(vd->ds));
		}

		static void vnc_set_area_dirty(DECLARE_BITMAP(dirty[VNC_MAX_HEIGHT],
		VNC_MAX_WIDTH / VNC_DIRTY_PIXELS_PER_BIT),
		int width, int height,
		int x, int y, int w, int h) {
		VncDisplay *vd,
		int x, int y, int w, int h)
		{
		int width = vnc_width(vd);
		int height = vnc_height(vd);

		/* this is needed this to ensure we updated all affected
		* blocks if x % VNC_DIRTY_PIXELS_PER_BIT != 0 */
		w += (x % VNC_DIRTY_PIXELS_PER_BIT);
		@@ -640,10 +655,8 @@ static void vnc_dpy_update(DisplayChangeListener *dcl,
		{
		VncDisplay *vd = container_of(dcl, VncDisplay, dcl);
		struct VncSurface *s = &vd->guest;
		int width = pixman_image_get_width(vd->server);
		int height = pixman_image_get_height(vd->server);

		vnc_set_area_dirty(s->dirty, width, height, x, y, w, h);
		vnc_set_area_dirty(s->dirty, vd, x, y, w, h);
		}

		void vnc_framebuffer_update(VncState *vs, int x, int y, int w, int h,
		@@ -713,6 +726,21 @@ void vnc_server_fb_ptr(VncDisplay vd, int x, int y)
		return ptr;
		}

		static void vnc_update_server_surface(VncDisplay *vd)
		{
		qemu_pixman_image_unref(vd->server);
		vd->server = NULL;

		if (QTAILQ_EMPTY(&vd->clients)) {
		return;
		}

		vd->server = pixman_image_create_bits(VNC_SERVER_FB_FORMAT,
		vnc_width(vd),
		vnc_height(vd),
		NULL, 0);
		}

		static void vnc_dpy_switch(DisplayChangeListener *dcl,
		DisplaySurface *surface)
		{
		@@ -721,26 +749,19 @@ static void vnc_dpy_switch(DisplayChangeListener *dcl,
		int width, height;

		vnc_abort_display_jobs(vd);
		vd->ds = surface;

		/* server surface */
		qemu_pixman_image_unref(vd->server);
		vd->ds = surface;
		width = MIN(VNC_MAX_WIDTH, ROUND_UP(surface_width(vd->ds),
		VNC_DIRTY_PIXELS_PER_BIT));
		height = MIN(VNC_MAX_HEIGHT, surface_height(vd->ds));
		vd->server = pixman_image_create_bits(VNC_SERVER_FB_FORMAT,
		width, height, NULL, 0);
		vnc_update_server_surface(vd);

		/* guest surface */
		#if 0 /* FIXME */
		if (ds_get_bytes_per_pixel(ds) != vd->guest.ds->pf.bytes_per_pixel)
		console_color_init(ds);
		#endif
		qemu_pixman_image_unref(vd->guest.fb);
		vd->guest.fb = pixman_image_ref(surface->image);
		vd->guest.format = surface->format;
		width = vnc_width(vd);
		height = vnc_height(vd);
		memset(vd->guest.dirty, 0x00, sizeof(vd->guest.dirty));
		vnc_set_area_dirty(vd->guest.dirty, width, height, 0, 0,
		vnc_set_area_dirty(vd->guest.dirty, vd, 0, 0,
		width, height);

		QTAILQ_FOREACH(vs, &vd->clients, next) {
		@@ -750,7 +771,7 @@ static void vnc_dpy_switch(DisplayChangeListener *dcl,
		vnc_cursor_define(vs);
		}
		memset(vs->dirty, 0x00, sizeof(vs->dirty));
		vnc_set_area_dirty(vs->dirty, width, height, 0, 0,
		vnc_set_area_dirty(vs->dirty, vd, 0, 0,
		width, height);
		}
		}
		@@ -1224,6 +1245,10 @@ void vnc_disconnect_finish(VncState *vs)
		if (vs->initialized) {
		QTAILQ_REMOVE(&vs->vd->clients, vs, next);
		qemu_remove_mouse_mode_change_notifier(&vs->mouse_mode_notifier);
		if (QTAILQ_EMPTY(&vs->vd->clients)) {
		/* last client gone */
		vnc_update_server_surface(vs->vd);
		}
		}

		if (vs->vd->lock_key_sync)
		@@ -2006,9 +2031,6 @@ static void ext_key_event(VncState *vs, int down,
		static void framebuffer_update_request(VncState *vs, int incremental,
		int x, int y, int w, int h)
		{
		int width = pixman_image_get_width(vs->vd->server);
		int height = pixman_image_get_height(vs->vd->server);

		vs->need_update = 1;

		if (incremental) {
		@@ -2016,7 +2038,7 @@ static void framebuffer_update_request(VncState *vs, int incremental,
		}

		vs->force_update = 1;
		vnc_set_area_dirty(vs->dirty, width, height, x, y, w, h);
		vnc_set_area_dirty(vs->dirty, vs->vd, x, y, w, h);
		}

		static void send_ext_key_event_ack(VncState *vs)
		@@ -2988,6 +3010,26 @@ static void vnc_connect(VncDisplay *vd, int csock,
		vs->csock = csock;
		vs->vd = vd;

		buffer_init(&vs->input, "vnc-input/%d", csock);
		buffer_init(&vs->output, "vnc-output/%d", csock);
		buffer_init(&vs->ws_input, "vnc-ws_input/%d", csock);
		buffer_init(&vs->ws_output, "vnc-ws_output/%d", csock);
		buffer_init(&vs->jobs_buffer, "vnc-jobs_buffer/%d", csock);

		buffer_init(&vs->tight.tight, "vnc-tight/%d", csock);
		buffer_init(&vs->tight.zlib, "vnc-tight-zlib/%d", csock);
		buffer_init(&vs->tight.gradient, "vnc-tight-gradient/%d", csock);
		#ifdef CONFIG_VNC_JPEG
		buffer_init(&vs->tight.jpeg, "vnc-tight-jpeg/%d", csock);
		#endif
		#ifdef CONFIG_VNC_PNG
		buffer_init(&vs->tight.png, "vnc-tight-png/%d", csock);
		#endif
		buffer_init(&vs->zlib.zlib, "vnc-zlib/%d", csock);
		buffer_init(&vs->zrle.zrle, "vnc-zrle/%d", csock);
		buffer_init(&vs->zrle.fb, "vnc-zrle-fb/%d", csock);
		buffer_init(&vs->zrle.zlib, "vnc-zrle-zlib/%d", csock);

		if (skipauth) {
		vs->auth = VNC_AUTH_NONE;
		vs->subauth = VNC_AUTH_INVALID;
		@@ -3045,6 +3087,7 @@ void vnc_init_state(VncState *vs)
		{
		vs->initialized = true;
		VncDisplay *vd = vs->vd;
		bool first_client = QTAILQ_EMPTY(&vd->clients);

		vs->last_x = -1;
		vs->last_y = -1;
		@@ -3058,6 +3101,9 @@ void vnc_init_state(VncState *vs)
		vs->bh = qemu_bh_new(vnc_jobs_bh, vs);

		QTAILQ_INSERT_TAIL(&vd->clients, vs, next);
		if (first_client) {
		vnc_update_server_surface(vd);
		}

		graphic_hw_update(vd->dcl.con);

		@@ -3570,8 +3616,6 @@ void vnc_display_open(const char id, Error *errp)
		"%d", (int)baseport + 5900);

		if (to) {
		saddr->u.inet->has_to = true;
		saddr->u.inet->to = to;
		saddr->u.inet->has_to = true;
		saddr->u.inet->to = to + 5900;
		}

util/buffer.c

+108 −2

Original line number	Diff line number	Diff line
		@@ -19,12 +19,77 @@
		*/

		#include "qemu/buffer.h"
		#include "trace.h"

		#define BUFFER_MIN_INIT_SIZE 4096
		#define BUFFER_MIN_SHRINK_SIZE 65536

		/* define the factor alpha for the expentional smoothing
		* that is used in the average size calculation. a shift
		* of 7 results in an alpha of 1/2^7. */
		#define BUFFER_AVG_SIZE_SHIFT 7

		static size_t buffer_req_size(Buffer *buffer, size_t len)
		{
		return MAX(BUFFER_MIN_INIT_SIZE,
		pow2ceil(buffer->offset + len));
		}

		static void buffer_adj_size(Buffer *buffer, size_t len)
		{
		size_t old = buffer->capacity;
		buffer->capacity = buffer_req_size(buffer, len);
		buffer->buffer = g_realloc(buffer->buffer, buffer->capacity);
		trace_buffer_resize(buffer->name ?: "unnamed",
		old, buffer->capacity);

		/* make it even harder for the buffer to shrink, reset average size
		* to currenty capacity if it is larger than the average. */
		buffer->avg_size = MAX(buffer->avg_size,
		buffer->capacity << BUFFER_AVG_SIZE_SHIFT);
		}

		void buffer_init(Buffer buffer, const char name, ...)
		{
		va_list ap;

		va_start(ap, name);
		buffer->name = g_strdup_vprintf(name, ap);
		va_end(ap);
		}

		static uint64_t buffer_get_avg_size(Buffer *buffer)
		{
		return buffer->avg_size >> BUFFER_AVG_SIZE_SHIFT;
		}

		void buffer_shrink(Buffer *buffer)
		{
		size_t new;

		/* Calculate the average size of the buffer as
		* avg_size = avg_size * ( 1 - a ) + required_size * a
		* where a is 1 / 2 ^ BUFFER_AVG_SIZE_SHIFT. */
		buffer->avg_size *= (1 << BUFFER_AVG_SIZE_SHIFT) - 1;
		buffer->avg_size >>= BUFFER_AVG_SIZE_SHIFT;
		buffer->avg_size += buffer_req_size(buffer, 0);

		/* And then only shrink if the average size of the buffer is much
		* too big, to avoid bumping up & down the buffers all the time.
		* realloc() isn't exactly cheap ... */
		new = buffer_req_size(buffer, buffer_get_avg_size(buffer));
		if (new < buffer->capacity >> 3 &&
		new >= BUFFER_MIN_SHRINK_SIZE) {
		buffer_adj_size(buffer, buffer_get_avg_size(buffer));
		}

		buffer_adj_size(buffer, 0);
		}

		void buffer_reserve(Buffer *buffer, size_t len)
		{
		if ((buffer->capacity - buffer->offset) < len) {
		buffer->capacity += (len + 1024);
		buffer->buffer = g_realloc(buffer->buffer, buffer->capacity);
		buffer_adj_size(buffer, len);
		}
		}

		@@ -41,14 +106,18 @@ uint8_t buffer_end(Buffer buffer)
		void buffer_reset(Buffer *buffer)
		{
		buffer->offset = 0;
		buffer_shrink(buffer);
		}

		void buffer_free(Buffer *buffer)
		{
		trace_buffer_free(buffer->name ?: "unnamed", buffer->capacity);
		g_free(buffer->buffer);
		g_free(buffer->name);
		buffer->offset = 0;
		buffer->capacity = 0;
		buffer->buffer = NULL;
		buffer->name = NULL;
		}

		void buffer_append(Buffer buffer, const void data, size_t len)
		@@ -62,4 +131,41 @@ void buffer_advance(Buffer *buffer, size_t len)
		memmove(buffer->buffer, buffer->buffer + len,
		(buffer->offset - len));
		buffer->offset -= len;
		buffer_shrink(buffer);
		}

		void buffer_move_empty(Buffer to, Buffer from)
		{
		trace_buffer_move_empty(to->name ?: "unnamed",
		from->offset,
		from->name ?: "unnamed");
		assert(to->offset == 0);

		g_free(to->buffer);
		to->offset = from->offset;
		to->capacity = from->capacity;
		to->buffer = from->buffer;

		from->offset = 0;
		from->capacity = 0;
		from->buffer = NULL;
		}

		void buffer_move(Buffer to, Buffer from)
		{
		if (to->offset == 0) {
		buffer_move_empty(to, from);
		return;
		}

		trace_buffer_move(to->name ?: "unnamed",
		from->offset,
		from->name ?: "unnamed");
		buffer_reserve(to, from->offset);
		buffer_append(to, from->buffer, from->offset);

		g_free(from->buffer);
		from->offset = 0;
		from->capacity = 0;
		from->buffer = NULL;
		}