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

Makefile.target

+2 −0

Original line number	Diff line number	Diff line
		# -- Mode: makefile --

		BUILD_DIR?=$(CURDIR)/..

		include ../config-host.mak
		include config-target.mak
		include config-devices.mak

arch_init.c

+2 −44

Original line number	Diff line number	Diff line
		@@ -609,52 +609,10 @@ ram_addr_t migration_bitmap_find_and_reset_dirty(MemoryRegion *mr,
		return (next - base) << TARGET_PAGE_BITS;
		}

		static inline bool migration_bitmap_set_dirty(ram_addr_t addr)
		{
		bool ret;
		int nr = addr >> TARGET_PAGE_BITS;

		ret = test_and_set_bit(nr, migration_bitmap);

		if (!ret) {
		migration_dirty_pages++;
		}
		return ret;
		}

		static void migration_bitmap_sync_range(ram_addr_t start, ram_addr_t length)
		{
		ram_addr_t addr;
		unsigned long page = BIT_WORD(start >> TARGET_PAGE_BITS);

		/* start address is aligned at the start of a word? */
		if (((page * BITS_PER_LONG) << TARGET_PAGE_BITS) == start) {
		int k;
		int nr = BITS_TO_LONGS(length >> TARGET_PAGE_BITS);
		unsigned long *src = ram_list.dirty_memory[DIRTY_MEMORY_MIGRATION];

		for (k = page; k < page + nr; k++) {
		if (src[k]) {
		unsigned long new_dirty;
		new_dirty = ~migration_bitmap[k];
		migration_bitmap[k] \|= src[k];
		new_dirty &= src[k];
		migration_dirty_pages += ctpopl(new_dirty);
		src[k] = 0;
		}
		}
		} else {
		for (addr = 0; addr < length; addr += TARGET_PAGE_SIZE) {
		if (cpu_physical_memory_get_dirty(start + addr,
		TARGET_PAGE_SIZE,
		DIRTY_MEMORY_MIGRATION)) {
		cpu_physical_memory_reset_dirty(start + addr,
		TARGET_PAGE_SIZE,
		DIRTY_MEMORY_MIGRATION);
		migration_bitmap_set_dirty(start + addr);
		}
		}
		}
		migration_dirty_pages +=
		cpu_physical_memory_sync_dirty_bitmap(migration_bitmap, start, length);
		}

bsd-user/main.c

+0 −4

Original line number	Diff line number	Diff line
		@@ -108,10 +108,6 @@ void cpu_list_unlock(void)
		/***********************************************************/
		/* CPUX86 core interface */

		void cpu_smm_update(CPUX86State *env)
		{
		}

		uint64_t cpu_get_tsc(CPUX86State *env)
		{
		return cpu_get_real_ticks();

cpus.c

+58 −26

Original line number	Diff line number	Diff line
		@@ -105,6 +105,7 @@ static bool all_cpu_threads_idle(void)

		/* Protected by TimersState seqlock */

		static bool icount_sleep = true;
		static int64_t vm_clock_warp_start = -1;
		/* Conversion factor from emulated instructions to virtual clock ticks. */
		static int icount_time_shift;
		@@ -393,15 +394,18 @@ void qemu_clock_warp(QEMUClockType type)
		return;
		}

		if (icount_sleep) {
		/*
		* If the CPUs have been sleeping, advance QEMU_CLOCK_VIRTUAL timer now.
		* This ensures that the deadline for the timer is computed correctly below.
		* This also makes sure that the insn counter is synchronized before the
		* CPU starts running, in case the CPU is woken by an event other than
		* the earliest QEMU_CLOCK_VIRTUAL timer.
		* This ensures that the deadline for the timer is computed correctly
		* below.
		* This also makes sure that the insn counter is synchronized before
		* the CPU starts running, in case the CPU is woken by an event other
		* than the earliest QEMU_CLOCK_VIRTUAL timer.
		*/
		icount_warp_rt(NULL);
		timer_del(icount_warp_timer);
		}
		if (!all_cpu_threads_idle()) {
		return;
		}
		@@ -415,6 +419,11 @@ void qemu_clock_warp(QEMUClockType type)
		clock = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_RT);
		deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
		if (deadline < 0) {
		static bool notified;
		if (!icount_sleep && !notified) {
		error_report("WARNING: icount sleep disabled and no active timers");
		notified = true;
		}
		return;
		}

		@@ -425,13 +434,24 @@ void qemu_clock_warp(QEMUClockType type)
		* interrupt to wake it up, but the interrupt never comes because
		* the vCPU isn't running any insns and thus doesn't advance the
		* QEMU_CLOCK_VIRTUAL.
		*
		* An extreme solution for this problem would be to never let VCPUs
		* sleep in icount mode if there is a pending QEMU_CLOCK_VIRTUAL
		* timer; rather time could just advance to the next QEMU_CLOCK_VIRTUAL
		* event. Instead, we do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL
		* after some "real" time, (related to the time left until the next
		* event) has passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
		*/
		if (!icount_sleep) {
		/*
		* We never let VCPUs sleep in no sleep icount mode.
		* If there is a pending QEMU_CLOCK_VIRTUAL timer we just advance
		* to the next QEMU_CLOCK_VIRTUAL event and notify it.
		* It is useful when we want a deterministic execution time,
		* isolated from host latencies.
		*/
		seqlock_write_lock(&timers_state.vm_clock_seqlock);
		timers_state.qemu_icount_bias += deadline;
		seqlock_write_unlock(&timers_state.vm_clock_seqlock);
		qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
		} else {
		/*
		* We do stop VCPUs and only advance QEMU_CLOCK_VIRTUAL after some
		* "real" time, (related to the time left until the next event) has
		* passed. The QEMU_CLOCK_VIRTUAL_RT clock will do this.
		* This avoids that the warps are visible externally; for example,
		* you will not be sending network packets continuously instead of
		* every 100ms.
		@@ -442,6 +462,7 @@ void qemu_clock_warp(QEMUClockType type)
		}
		seqlock_write_unlock(&timers_state.vm_clock_seqlock);
		timer_mod_anticipate(icount_warp_timer, clock + deadline);
		}
		} else if (deadline == 0) {
		qemu_clock_notify(QEMU_CLOCK_VIRTUAL);
		}
		@@ -504,9 +525,18 @@ void configure_icount(QemuOpts opts, Error *errp)
		}
		return;
		}
		icount_align_option = qemu_opt_get_bool(opts, "align", false);

		icount_sleep = qemu_opt_get_bool(opts, "sleep", true);
		if (icount_sleep) {
		icount_warp_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL_RT,
		icount_warp_rt, NULL);
		}

		icount_align_option = qemu_opt_get_bool(opts, "align", false);

		if (icount_align_option && !icount_sleep) {
		error_setg(errp, "align=on and sleep=no are incompatible");
		}
		if (strcmp(option, "auto") != 0) {
		errno = 0;
		icount_time_shift = strtol(option, &rem_str, 0);
		@@ -517,6 +547,8 @@ void configure_icount(QemuOpts opts, Error *errp)
		return;
		} else if (icount_align_option) {
		error_setg(errp, "shift=auto and align=on are incompatible");
		} else if (!icount_sleep) {
		error_setg(errp, "shift=auto and sleep=no are incompatible");
		}

		use_icount = 2;

cputlb.c

+3 −4

Original line number	Diff line number	Diff line
		@@ -125,14 +125,13 @@ void tlb_flush_page(CPUState *cpu, target_ulong addr)
		can be detected */
		void tlb_protect_code(ram_addr_t ram_addr)
		{
		cpu_physical_memory_reset_dirty(ram_addr, TARGET_PAGE_SIZE,
		cpu_physical_memory_test_and_clear_dirty(ram_addr, TARGET_PAGE_SIZE,
		DIRTY_MEMORY_CODE);
		}

		/* update the TLB so that writes in physical page 'phys_addr' are no longer
		tested for self modifying code */
		void tlb_unprotect_code_phys(CPUState *cpu, ram_addr_t ram_addr,
		target_ulong vaddr)
		void tlb_unprotect_code(ram_addr_t ram_addr)
		{
		cpu_physical_memory_set_dirty_flag(ram_addr, DIRTY_MEMORY_CODE);
		}