diff options
| -rw-r--r-- | Makefile | 2 | ||||
| -rw-r--r-- | block/qcow2.c | 16 | ||||
| -rw-r--r-- | block/qcow2.h | 1 | ||||
| -rw-r--r-- | fpu/softfloat.c | 30 | ||||
| -rw-r--r-- | linux-user/signal.c | 12 | ||||
| -rw-r--r-- | target/m68k/op_helper.c | 33 | ||||
| -rw-r--r-- | tcg/mips/tcg-target.inc.c | 11 | ||||
| -rwxr-xr-x | tests/qemu-iotests/169 | 48 |
8 files changed, 82 insertions, 71 deletions
@@ -856,7 +856,7 @@ ifneq ($(BLOBS),) $(INSTALL_DATA) $(SRC_PATH)/pc-bios/$$x "$(DESTDIR)$(qemu_datadir)"; \ done endif -ifeq ($(CONFIG_GTK),m) +ifdef CONFIG_GTK $(MAKE) -C po $@ endif $(INSTALL_DIR) "$(DESTDIR)$(qemu_datadir)/keymaps" diff --git a/block/qcow2.c b/block/qcow2.c index 486f3e83b7..ef68772aca 100644 --- a/block/qcow2.c +++ b/block/qcow2.c @@ -1142,6 +1142,7 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, uint64_t ext_end; uint64_t l1_vm_state_index; bool update_header = false; + bool header_updated = false; ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); if (ret < 0) { @@ -1480,10 +1481,9 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, s->autoclear_features &= QCOW2_AUTOCLEAR_MASK; } - if (bdrv_dirty_bitmap_next(bs, NULL)) { - /* It's some kind of reopen with already existing dirty bitmaps. There - * are no known cases where we need loading bitmaps in such situation, - * so it's safer don't load them. + if (s->dirty_bitmaps_loaded) { + /* It's some kind of reopen. There are no known cases where we need to + * reload bitmaps in such a situation, so it's safer to skip them. * * Moreover, if we have some readonly bitmaps and we are reopening for * rw we should reopen bitmaps correspondingly. @@ -1491,13 +1491,13 @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options, if (bdrv_has_readonly_bitmaps(bs) && !bdrv_is_read_only(bs) && !(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) { - bool header_updated = false; qcow2_reopen_bitmaps_rw_hint(bs, &header_updated, &local_err); - update_header = update_header && !header_updated; } - } else if (qcow2_load_dirty_bitmaps(bs, &local_err)) { - update_header = false; + } else { + header_updated = qcow2_load_dirty_bitmaps(bs, &local_err); + s->dirty_bitmaps_loaded = true; } + update_header = update_header && !header_updated; if (local_err != NULL) { error_propagate(errp, local_err); ret = -EINVAL; diff --git a/block/qcow2.h b/block/qcow2.h index d301f77cea..adf5c3950f 100644 --- a/block/qcow2.h +++ b/block/qcow2.h @@ -298,6 +298,7 @@ typedef struct BDRVQcow2State { uint32_t nb_bitmaps; uint64_t bitmap_directory_size; uint64_t bitmap_directory_offset; + bool dirty_bitmaps_loaded; int flags; int qcow_version; diff --git a/fpu/softfloat.c b/fpu/softfloat.c index b46dccc63e..d90d79d777 100644 --- a/fpu/softfloat.c +++ b/fpu/softfloat.c @@ -1146,6 +1146,11 @@ static FloatParts div_floats(FloatParts a, FloatParts b, float_status *s) a.cls = float_class_dnan; return a; } + /* Inf / x or 0 / x */ + if (a.cls == float_class_inf || a.cls == float_class_zero) { + a.sign = sign; + return a; + } /* Div 0 => Inf */ if (b.cls == float_class_zero) { s->float_exception_flags |= float_flag_divbyzero; @@ -1153,11 +1158,6 @@ static FloatParts div_floats(FloatParts a, FloatParts b, float_status *s) a.sign = sign; return a; } - /* Inf / x or 0 / x */ - if (a.cls == float_class_inf || a.cls == float_class_zero) { - a.sign = sign; - return a; - } /* Div by Inf */ if (b.cls == float_class_inf) { a.cls = float_class_zero; @@ -1344,8 +1344,10 @@ static int64_t round_to_int_and_pack(FloatParts in, int rmode, case float_class_qnan: case float_class_dnan: case float_class_msnan: + s->float_exception_flags = orig_flags | float_flag_invalid; return max; case float_class_inf: + s->float_exception_flags = orig_flags | float_flag_invalid; return p.sign ? min : max; case float_class_zero: return 0; @@ -1437,6 +1439,7 @@ static uint64_t round_to_uint_and_pack(FloatParts in, int rmode, uint64_t max, s->float_exception_flags = orig_flags | float_flag_invalid; return max; case float_class_inf: + s->float_exception_flags = orig_flags | float_flag_invalid; return p.sign ? 0 : max; case float_class_zero: return 0; @@ -1704,7 +1707,6 @@ static FloatParts minmax_floats(FloatParts a, FloatParts b, bool ismin, return pick_nan(a, b, s); } else { int a_exp, b_exp; - bool a_sign, b_sign; switch (a.cls) { case float_class_normal: @@ -1735,20 +1737,22 @@ static FloatParts minmax_floats(FloatParts a, FloatParts b, bool ismin, break; } - a_sign = a.sign; - b_sign = b.sign; - if (ismag) { - a_sign = b_sign = 0; + if (ismag && (a_exp != b_exp || a.frac != b.frac)) { + bool a_less = a_exp < b_exp; + if (a_exp == b_exp) { + a_less = a.frac < b.frac; + } + return a_less ^ ismin ? b : a; } - if (a_sign == b_sign) { + if (a.sign == b.sign) { bool a_less = a_exp < b_exp; if (a_exp == b_exp) { a_less = a.frac < b.frac; } - return a_sign ^ a_less ^ ismin ? b : a; + return a.sign ^ a_less ^ ismin ? b : a; } else { - return a_sign ^ ismin ? b : a; + return a.sign ^ ismin ? b : a; } } } diff --git a/linux-user/signal.c b/linux-user/signal.c index 8d9e6e8410..e6dfe0adfd 100644 --- a/linux-user/signal.c +++ b/linux-user/signal.c @@ -1843,6 +1843,12 @@ static void target_setup_frame(int usig, struct target_sigaction *ka, layout.total_size += sizeof(struct target_aarch64_ctx); } + /* We must always provide at least the standard 4K reserved space, + * even if we don't use all of it (this is part of the ABI) + */ + layout.total_size = MAX(layout.total_size, + sizeof(struct target_rt_sigframe)); + /* Reserve space for the return code. On a real system this would * be within the VDSO. So, despite the name this is not a "real" * record within the frame. @@ -1850,12 +1856,6 @@ static void target_setup_frame(int usig, struct target_sigaction *ka, fr_ofs = layout.total_size; layout.total_size += sizeof(struct target_rt_frame_record); - /* We must always provide at least the standard 4K reserved space, - * even if we don't use all of it (this is part of the ABI) - */ - layout.total_size = MAX(layout.total_size, - sizeof(struct target_rt_sigframe)); - frame_addr = get_sigframe(ka, env, layout.total_size); trace_user_setup_frame(env, frame_addr); if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0)) { diff --git a/target/m68k/op_helper.c b/target/m68k/op_helper.c index 3a7f7f2219..8d09ed91c4 100644 --- a/target/m68k/op_helper.c +++ b/target/m68k/op_helper.c @@ -287,22 +287,25 @@ static inline void do_stack_frame(CPUM68KState *env, uint32_t *sp, uint16_t format, uint16_t sr, uint32_t addr, uint32_t retaddr) { - CPUState *cs = CPU(m68k_env_get_cpu(env)); - switch (format) { - case 4: - *sp -= 4; - cpu_stl_kernel(env, *sp, env->pc); - *sp -= 4; - cpu_stl_kernel(env, *sp, addr); - break; - case 3: - case 2: - *sp -= 4; - cpu_stl_kernel(env, *sp, addr); - break; + if (m68k_feature(env, M68K_FEATURE_QUAD_MULDIV)) { + /* all except 68000 */ + CPUState *cs = CPU(m68k_env_get_cpu(env)); + switch (format) { + case 4: + *sp -= 4; + cpu_stl_kernel(env, *sp, env->pc); + *sp -= 4; + cpu_stl_kernel(env, *sp, addr); + break; + case 3: + case 2: + *sp -= 4; + cpu_stl_kernel(env, *sp, addr); + break; + } + *sp -= 2; + cpu_stw_kernel(env, *sp, (format << 12) + (cs->exception_index << 2)); } - *sp -= 2; - cpu_stw_kernel(env, *sp, (format << 12) + (cs->exception_index << 2)); *sp -= 4; cpu_stl_kernel(env, *sp, retaddr); *sp -= 2; diff --git a/tcg/mips/tcg-target.inc.c b/tcg/mips/tcg-target.inc.c index 4b55ab8856..ca5f1d4894 100644 --- a/tcg/mips/tcg-target.inc.c +++ b/tcg/mips/tcg-target.inc.c @@ -1229,13 +1229,10 @@ static void tcg_out_tlb_load(TCGContext *s, TCGReg base, TCGReg addrl, tcg_out_opc_reg(s, ALIAS_PADD, TCG_REG_A0, TCG_REG_A0, TCG_AREG0); /* Compensate for very large offsets. */ - if (add_off >= 0x8000) { - /* Most target env are smaller than 32k; none are larger than 64k. - Simplify the logic here merely to offset by 0x7ff0, giving us a - range just shy of 64k. Check this assumption. */ - QEMU_BUILD_BUG_ON(offsetof(CPUArchState, - tlb_table[NB_MMU_MODES - 1][1]) - > 0x7ff0 + 0x7fff); + while (add_off >= 0x8000) { + /* Most target env are smaller than 32k, but a few are larger than 64k, + * so handle an arbitrarily large offset. + */ tcg_out_opc_imm(s, ALIAS_PADDI, TCG_REG_A0, TCG_REG_A0, 0x7ff0); cmp_off -= 0x7ff0; add_off -= 0x7ff0; diff --git a/tests/qemu-iotests/169 b/tests/qemu-iotests/169 index 153b10b6e7..f243db9955 100755 --- a/tests/qemu-iotests/169 +++ b/tests/qemu-iotests/169 @@ -31,6 +31,8 @@ disk_a = os.path.join(iotests.test_dir, 'disk_a') disk_b = os.path.join(iotests.test_dir, 'disk_b') size = '1M' mig_file = os.path.join(iotests.test_dir, 'mig_file') +mig_cmd = 'exec: cat > ' + mig_file +incoming_cmd = 'exec: cat ' + mig_file class TestDirtyBitmapMigration(iotests.QMPTestCase): @@ -49,7 +51,6 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): self.vm_a.launch() self.vm_b = iotests.VM(path_suffix='b') - self.vm_b.add_incoming("exec: cat '" + mig_file + "'") def add_bitmap(self, vm, granularity, persistent): params = {'node': 'drive0', @@ -86,36 +87,30 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): (0xa0201, 0x1000)) should_migrate = migrate_bitmaps or persistent and shared_storage + mig_caps = [{'capability': 'events', 'state': True}] + if migrate_bitmaps: + mig_caps.append({'capability': 'dirty-bitmaps', 'state': True}) + result = self.vm_a.qmp('migrate-set-capabilities', + capabilities=mig_caps) + self.assert_qmp(result, 'return', {}) + + self.vm_b.add_incoming(incoming_cmd if online else "defer") self.vm_b.add_drive(disk_a if shared_storage else disk_b) if online: os.mkfifo(mig_file) self.vm_b.launch() + result = self.vm_b.qmp('migrate-set-capabilities', + capabilities=mig_caps) + self.assert_qmp(result, 'return', {}) self.add_bitmap(self.vm_a, granularity, persistent) for r in regions: self.vm_a.hmp_qemu_io('drive0', 'write %d %d' % r) sha256 = self.get_bitmap_hash(self.vm_a) - if migrate_bitmaps: - capabilities = [{'capability': 'dirty-bitmaps', 'state': True}] - - result = self.vm_a.qmp('migrate-set-capabilities', - capabilities=capabilities) - self.assert_qmp(result, 'return', {}) - - if online: - result = self.vm_b.qmp('migrate-set-capabilities', - capabilities=capabilities) - self.assert_qmp(result, 'return', {}) - - result = self.vm_a.qmp('migrate-set-capabilities', - capabilities=[{'capability': 'events', - 'state': True}]) - self.assert_qmp(result, 'return', {}) - - result = self.vm_a.qmp('migrate', uri='exec:cat>' + mig_file) + result = self.vm_a.qmp('migrate', uri=mig_cmd) while True: event = self.vm_a.event_wait('MIGRATION') if event['data']['status'] == 'completed': @@ -124,14 +119,25 @@ class TestDirtyBitmapMigration(iotests.QMPTestCase): if not online: self.vm_a.shutdown() self.vm_b.launch() - # TODO enable bitmap capability for vm_b in this case + result = self.vm_b.qmp('migrate-set-capabilities', + capabilities=mig_caps) + self.assert_qmp(result, 'return', {}) + result = self.vm_b.qmp('migrate-incoming', uri=incoming_cmd) + self.assert_qmp(result, 'return', {}) - self.vm_b.event_wait("RESUME", timeout=10.0) + while True: + event = self.vm_b.event_wait('MIGRATION') + if event['data']['status'] == 'completed': + break self.check_bitmap(self.vm_b, sha256 if should_migrate else False) if should_migrate: self.vm_b.shutdown() + # recreate vm_b, as we don't want -incoming option (this will lead + # to "cat" process left alive after test finish) + self.vm_b = iotests.VM(path_suffix='b') + self.vm_b.add_drive(disk_a if shared_storage else disk_b) self.vm_b.launch() self.check_bitmap(self.vm_b, sha256 if persistent else False) |