Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream' into staging (2ee55b83) · Commits · SUMMER2020 / students / proj-2021291

backends/Makefile.objs

+1 −1

Original line number	Diff line number	Diff line
		common-obj-y += rng.o rng-egd.o
		common-obj-$(CONFIG_POSIX) += rng-random.o

		common-obj-y += msmouse.o
		common-obj-y += msmouse.o testdev.o
		common-obj-$(CONFIG_BRLAPI) += baum.o
		baum.o-cflags := $(SDL_CFLAGS)

backends/testdev.c

0 → 100644

+131 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU Char Device for testsuite control
		*
		* Copyright (c) 2014 Red Hat, Inc.
		*
		* Author: Paolo Bonzini <pbonzini@redhat.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 "qemu-common.h"
		#include "sysemu/char.h"

		#define BUF_SIZE 32

		typedef struct {
		CharDriverState *chr;
		uint8_t in_buf[32];
		int in_buf_used;
		} TestdevCharState;

		/* Try to interpret a whole incoming packet */
		static int testdev_eat_packet(TestdevCharState *testdev)
		{
		const uint8_t *cur = testdev->in_buf;
		int len = testdev->in_buf_used;
		uint8_t c;
		int arg;

		#define EAT(c) do { \
		if (!len--) { \
		return 0; \
		} \
		c = *cur++; \
		} while (0)

		EAT(c);

		while (isspace(c)) {
		EAT(c);
		}

		arg = 0;
		while (isdigit(c)) {
		arg = arg * 10 + c - '0';
		EAT(c);
		}

		while (isspace(c)) {
		EAT(c);
		}

		switch (c) {
		case 'q':
		exit((arg << 1) \| 1);
		break;
		default:
		break;
		}
		return cur - testdev->in_buf;
		}

		/* The other end is writing some data. Store it and try to interpret */
		static int testdev_write(CharDriverState chr, const uint8_t buf, int len)
		{
		TestdevCharState *testdev = chr->opaque;
		int tocopy, eaten, orig_len = len;

		while (len) {
		/* Complete our buffer as much as possible */
		tocopy = MIN(len, BUF_SIZE - testdev->in_buf_used);

		memcpy(testdev->in_buf + testdev->in_buf_used, buf, tocopy);
		testdev->in_buf_used += tocopy;
		buf += tocopy;
		len -= tocopy;

		/* Interpret it as much as possible */
		while (testdev->in_buf_used > 0 &&
		(eaten = testdev_eat_packet(testdev)) > 0) {
		memmove(testdev->in_buf, testdev->in_buf + eaten,
		testdev->in_buf_used - eaten);
		testdev->in_buf_used -= eaten;
		}
		}
		return orig_len;
		}

		static void testdev_close(struct CharDriverState *chr)
		{
		TestdevCharState *testdev = chr->opaque;

		g_free(testdev);
		}

		CharDriverState *chr_testdev_init(void)
		{
		TestdevCharState *testdev;
		CharDriverState *chr;

		testdev = g_malloc0(sizeof(TestdevCharState));
		testdev->chr = chr = g_malloc0(sizeof(CharDriverState));

		chr->opaque = testdev;
		chr->chr_write = testdev_write;
		chr->chr_close = testdev_close;

		return chr;
		}

		static void register_types(void)
		{
		register_char_driver_qapi("testdev", CHARDEV_BACKEND_KIND_TESTDEV, NULL);
		}

		type_init(register_types);

cpu-exec.c

+116 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,109 @@
		#include "tcg.h"
		#include "qemu/atomic.h"
		#include "sysemu/qtest.h"
		#include "qemu/timer.h"

		/* -icount align implementation. */

		typedef struct SyncClocks {
		int64_t diff_clk;
		int64_t last_cpu_icount;
		int64_t realtime_clock;
		} SyncClocks;

		#if !defined(CONFIG_USER_ONLY)
		/* Allow the guest to have a max 3ms advance.
		* The difference between the 2 clocks could therefore
		* oscillate around 0.
		*/
		#define VM_CLOCK_ADVANCE 3000000
		#define THRESHOLD_REDUCE 1.5
		#define MAX_DELAY_PRINT_RATE 2000000000LL
		#define MAX_NB_PRINTS 100

		static void align_clocks(SyncClocks sc, const CPUState cpu)
		{
		int64_t cpu_icount;

		if (!icount_align_option) {
		return;
		}

		cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low;
		sc->diff_clk += cpu_icount_to_ns(sc->last_cpu_icount - cpu_icount);
		sc->last_cpu_icount = cpu_icount;

		if (sc->diff_clk > VM_CLOCK_ADVANCE) {
		#ifndef _WIN32
		struct timespec sleep_delay, rem_delay;
		sleep_delay.tv_sec = sc->diff_clk / 1000000000LL;
		sleep_delay.tv_nsec = sc->diff_clk % 1000000000LL;
		if (nanosleep(&sleep_delay, &rem_delay) < 0) {
		sc->diff_clk -= (sleep_delay.tv_sec - rem_delay.tv_sec) * 1000000000LL;
		sc->diff_clk -= sleep_delay.tv_nsec - rem_delay.tv_nsec;
		} else {
		sc->diff_clk = 0;
		}
		#else
		Sleep(sc->diff_clk / SCALE_MS);
		sc->diff_clk = 0;
		#endif
		}
		}

		static void print_delay(const SyncClocks *sc)
		{
		static float threshold_delay;
		static int64_t last_realtime_clock;
		static int nb_prints;

		if (icount_align_option &&
		sc->realtime_clock - last_realtime_clock >= MAX_DELAY_PRINT_RATE &&
		nb_prints < MAX_NB_PRINTS) {
		if ((-sc->diff_clk / (float)1000000000LL > threshold_delay) \|\|
		(-sc->diff_clk / (float)1000000000LL <
		(threshold_delay - THRESHOLD_REDUCE))) {
		threshold_delay = (-sc->diff_clk / 1000000000LL) + 1;
		printf("Warning: The guest is now late by %.1f to %.1f seconds\n",
		threshold_delay - 1,
		threshold_delay);
		nb_prints++;
		last_realtime_clock = sc->realtime_clock;
		}
		}
		}

		static void init_delay_params(SyncClocks *sc,
		const CPUState *cpu)
		{
		if (!icount_align_option) {
		return;
		}
		sc->realtime_clock = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
		sc->diff_clk = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) -
		sc->realtime_clock +
		cpu_get_clock_offset();
		sc->last_cpu_icount = cpu->icount_extra + cpu->icount_decr.u16.low;
		if (sc->diff_clk < max_delay) {
		max_delay = sc->diff_clk;
		}
		if (sc->diff_clk > max_advance) {
		max_advance = sc->diff_clk;
		}

		/* Print every 2s max if the guest is late. We limit the number
		of printed messages to NB_PRINT_MAX(currently 100) */
		print_delay(sc);
		}
		#else
		static void align_clocks(SyncClocks sc, const CPUState cpu)
		{
		}

		static void init_delay_params(SyncClocks sc, const CPUState cpu)
		{
		}
		#endif /* CONFIG USER ONLY */

		void cpu_loop_exit(CPUState *cpu)
		{
		@@ -227,6 +330,8 @@ int cpu_exec(CPUArchState *env)
		TranslationBlock *tb;
		uint8_t *tc_ptr;
		uintptr_t next_tb;
		SyncClocks sc;

		/* This must be volatile so it is not trashed by longjmp() */
		volatile bool have_tb_lock = false;

		@@ -283,6 +388,13 @@ int cpu_exec(CPUArchState *env)
		#endif
		cpu->exception_index = -1;

		/* Calculate difference between guest clock and host clock.
		* This delay includes the delay of the last cycle, so
		* what we have to do is sleep until it is 0. As for the
		* advance/delay we gain here, we try to fix it next time.
		*/
		init_delay_params(&sc, cpu);

		/* prepare setjmp context for exception handling */
		for(;;) {
		if (sigsetjmp(cpu->jmp_env, 0) == 0) {
		@@ -672,6 +784,7 @@ int cpu_exec(CPUArchState *env)
		if (insns_left > 0) {
		/* Execute remaining instructions. */
		cpu_exec_nocache(env, insns_left, tb);
		align_clocks(&sc, cpu);
		}
		cpu->exception_index = EXCP_INTERRUPT;
		next_tb = 0;
		@@ -684,6 +797,9 @@ int cpu_exec(CPUArchState *env)
		}
		}
		cpu->current_tb = NULL;
		/* Try to align the host and virtual clocks
		if the guest is in advance */
		align_clocks(&sc, cpu);
		/* reset soft MMU for next block (it can currently
		only be set by a memory fault) */
		} /* for(;;) */

cpus.c

+101 −17

Original line number	Diff line number	Diff line
		@@ -64,6 +64,8 @@
		#endif /* CONFIG_LINUX */

		static CPUState *next_cpu;
		int64_t max_delay;
		int64_t max_advance;

		bool cpu_is_stopped(CPUState *cpu)
		{
		@@ -102,17 +104,12 @@ static bool all_cpu_threads_idle(void)

		/* Protected by TimersState seqlock */

		/* Compensate for varying guest execution speed. */
		static int64_t qemu_icount_bias;
		static int64_t vm_clock_warp_start;
		static int64_t vm_clock_warp_start = -1;
		/* Conversion factor from emulated instructions to virtual clock ticks. */
		static int icount_time_shift;
		/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
		#define MAX_ICOUNT_SHIFT 10

		/* Only written by TCG thread */
		static int64_t qemu_icount;

		static QEMUTimer *icount_rt_timer;
		static QEMUTimer *icount_vm_timer;
		static QEMUTimer *icount_warp_timer;
		@@ -129,6 +126,11 @@ typedef struct TimersState {
		int64_t cpu_clock_offset;
		int32_t cpu_ticks_enabled;
		int64_t dummy;

		/* Compensate for varying guest execution speed. */
		int64_t qemu_icount_bias;
		/* Only written by TCG thread */
		int64_t qemu_icount;
		} TimersState;

		static TimersState timers_state;
		@@ -139,14 +141,14 @@ static int64_t cpu_get_icount_locked(void)
		int64_t icount;
		CPUState *cpu = current_cpu;

		icount = qemu_icount;
		icount = timers_state.qemu_icount;
		if (cpu) {
		if (!cpu_can_do_io(cpu)) {
		fprintf(stderr, "Bad clock read\n");
		}
		icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
		}
		return qemu_icount_bias + (icount << icount_time_shift);
		return timers_state.qemu_icount_bias + cpu_icount_to_ns(icount);
		}

		int64_t cpu_get_icount(void)
		@@ -162,6 +164,11 @@ int64_t cpu_get_icount(void)
		return icount;
		}

		int64_t cpu_icount_to_ns(int64_t icount)
		{
		return icount << icount_time_shift;
		}

		/* return the host CPU cycle counter and handle stop/restart */
		/* Caller must hold the BQL */
		int64_t cpu_get_ticks(void)
		@@ -214,6 +221,23 @@ int64_t cpu_get_clock(void)
		return ti;
		}

		/* return the offset between the host clock and virtual CPU clock */
		int64_t cpu_get_clock_offset(void)
		{
		int64_t ti;
		unsigned start;

		do {
		start = seqlock_read_begin(&timers_state.vm_clock_seqlock);
		ti = timers_state.cpu_clock_offset;
		if (!timers_state.cpu_ticks_enabled) {
		ti -= get_clock();
		}
		} while (seqlock_read_retry(&timers_state.vm_clock_seqlock, start));

		return -ti;
		}

		/* enable cpu_get_ticks()
		* Caller must hold BQL which server as mutex for vm_clock_seqlock.
		*/
		@@ -284,7 +308,8 @@ static void icount_adjust(void)
		icount_time_shift++;
		}
		last_delta = delta;
		qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
		timers_state.qemu_icount_bias = cur_icount
		- (timers_state.qemu_icount << icount_time_shift);
		seqlock_write_unlock(&timers_state.vm_clock_seqlock);
		}

		@@ -333,7 +358,7 @@ static void icount_warp_rt(void *opaque)
		int64_t delta = cur_time - cur_icount;
		warp_delta = MIN(warp_delta, delta);
		}
		qemu_icount_bias += warp_delta;
		timers_state.qemu_icount_bias += warp_delta;
		}
		vm_clock_warp_start = -1;
		seqlock_write_unlock(&timers_state.vm_clock_seqlock);
		@@ -351,7 +376,7 @@ void qtest_clock_warp(int64_t dest)
		int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
		int64_t warp = qemu_soonest_timeout(dest - clock, deadline);
		seqlock_write_lock(&timers_state.vm_clock_seqlock);
		qemu_icount_bias += warp;
		timers_state.qemu_icount_bias += warp;
		seqlock_write_unlock(&timers_state.vm_clock_seqlock);

		qemu_clock_run_timers(QEMU_CLOCK_VIRTUAL);
		@@ -428,6 +453,25 @@ void qemu_clock_warp(QEMUClockType type)
		}
		}

		static bool icount_state_needed(void *opaque)
		{
		return use_icount;
		}

		/*
		* This is a subsection for icount migration.
		*/
		static const VMStateDescription icount_vmstate_timers = {
		.name = "timer/icount",
		.version_id = 1,
		.minimum_version_id = 1,
		.fields = (VMStateField[]) {
		VMSTATE_INT64(qemu_icount_bias, TimersState),
		VMSTATE_INT64(qemu_icount, TimersState),
		VMSTATE_END_OF_LIST()
		}
		};

		static const VMStateDescription vmstate_timers = {
		.name = "timer",
		.version_id = 2,
		@@ -437,23 +481,44 @@ static const VMStateDescription vmstate_timers = {
		VMSTATE_INT64(dummy, TimersState),
		VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
		VMSTATE_END_OF_LIST()
		},
		.subsections = (VMStateSubsection[]) {
		{
		.vmsd = &icount_vmstate_timers,
		.needed = icount_state_needed,
		}, {
		/* empty */
		}
		}
		};

		void configure_icount(const char *option)
		void configure_icount(QemuOpts opts, Error *errp)
		{
		const char *option;
		char *rem_str = NULL;

		seqlock_init(&timers_state.vm_clock_seqlock, NULL);
		vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
		option = qemu_opt_get(opts, "shift");
		if (!option) {
		if (qemu_opt_get(opts, "align") != NULL) {
		error_setg(errp, "Please specify shift option when using align");
		}
		return;
		}

		icount_align_option = qemu_opt_get_bool(opts, "align", false);
		icount_warp_timer = timer_new_ns(QEMU_CLOCK_REALTIME,
		icount_warp_rt, NULL);
		if (strcmp(option, "auto") != 0) {
		icount_time_shift = strtol(option, NULL, 0);
		errno = 0;
		icount_time_shift = strtol(option, &rem_str, 0);
		if (errno != 0 \|\| *rem_str != '\0' \|\| !strlen(option)) {
		error_setg(errp, "icount: Invalid shift value");
		}
		use_icount = 1;
		return;
		} else if (icount_align_option) {
		error_setg(errp, "shift=auto and align=on are incompatible");
		}

		use_icount = 2;
		@@ -1250,7 +1315,8 @@ static int tcg_cpu_exec(CPUArchState *env)
		int64_t count;
		int64_t deadline;
		int decr;
		qemu_icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
		timers_state.qemu_icount -= (cpu->icount_decr.u16.low
		+ cpu->icount_extra);
		cpu->icount_decr.u16.low = 0;
		cpu->icount_extra = 0;
		deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
		@@ -1265,7 +1331,7 @@ static int tcg_cpu_exec(CPUArchState *env)
		}

		count = qemu_icount_round(deadline);
		qemu_icount += count;
		timers_state.qemu_icount += count;
		decr = (count > 0xffff) ? 0xffff : count;
		count -= decr;
		cpu->icount_decr.u16.low = decr;
		@@ -1278,7 +1344,8 @@ static int tcg_cpu_exec(CPUArchState *env)
		if (use_icount) {
		/* Fold pending instructions back into the
		instruction counter, and clear the interrupt flag. */
		qemu_icount -= (cpu->icount_decr.u16.low + cpu->icount_extra);
		timers_state.qemu_icount -= (cpu->icount_decr.u16.low
		+ cpu->icount_extra);
		cpu->icount_decr.u32 = 0;
		cpu->icount_extra = 0;
		}
		@@ -1487,3 +1554,20 @@ void qmp_inject_nmi(Error **errp)
		error_set(errp, QERR_UNSUPPORTED);
		#endif
		}

		void dump_drift_info(FILE *f, fprintf_function cpu_fprintf)
		{
		if (!use_icount) {
		return;
		}

		cpu_fprintf(f, "Host - Guest clock %"PRIi64" ms\n",
		(cpu_get_clock() - cpu_get_icount())/SCALE_MS);
		if (icount_align_option) {
		cpu_fprintf(f, "Max guest delay %"PRIi64" ms\n", -max_delay/SCALE_MS);
		cpu_fprintf(f, "Max guest advance %"PRIi64" ms\n", max_advance/SCALE_MS);
		} else {
		cpu_fprintf(f, "Max guest delay NA\n");
		cpu_fprintf(f, "Max guest advance NA\n");
		}
		}

include/qemu-common.h

+7 −1

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@
		#include <assert.h>
		#include <signal.h>
		#include "glib-compat.h"
		#include "qemu/option.h"

		#ifdef _WIN32
		#include "sysemu/os-win32.h"
		@@ -105,8 +106,13 @@ static inline char realpath(const char path, char *resolved_path)
		#endif

		/* icount */
		void configure_icount(const char *option);
		void configure_icount(QemuOpts opts, Error *errp);
		extern int use_icount;
		extern int icount_align_option;
		/* drift information for info jit command */
		extern int64_t max_delay;
		extern int64_t max_advance;
		void dump_drift_info(FILE *f, fprintf_function cpu_fprintf);

		#include "qemu/osdep.h"
		#include "qemu/bswap.h"