Merge remote-tracking branch 'remotes/mcayland/tags/qemu-openbios-20200727' into staging
qemu-openbios queue
# gpg: Signature made Mon 27 Jul 2020 16:09:34 BST
# gpg: using RSA key CC621AB98E82200D915CC9C45BC2C56FAE0F321F
# gpg: issuer "mark.cave-ayland@ilande.co.uk"
# gpg: Good signature from "Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>" [full]
# Primary key fingerprint: CC62 1AB9 8E82 200D 915C C9C4 5BC2 C56F AE0F 321F
* remotes/mcayland/tags/qemu-openbios-20200727:
Update OpenBIOS images to 7f28286f built from submodule.
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
diff --git a/.shippable.yml b/.shippable.yml
index f6b7424..89d8be4 100644
--- a/.shippable.yml
+++ b/.shippable.yml
@@ -27,7 +27,7 @@
TARGET_LIST=ppc64-softmmu,ppc64-linux-user,ppc64abi32-linux-user
build:
pre_ci_boot:
- image_name: registry.gitlab.com/qemu-project/qemu/${IMAGE}
+ image_name: registry.gitlab.com/qemu-project/qemu/qemu/${IMAGE}
image_tag: latest
pull: true
options: "-e HOME=/root"
diff --git a/MAINTAINERS b/MAINTAINERS
index 3395abd..0886eb3 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2667,6 +2667,14 @@
F: include/hw/i2c/smbus_slave.h
F: include/hw/i2c/smbus_eeprom.h
+Firmware schema specifications
+M: Laszlo Ersek <lersek@redhat.com>
+M: Philippe Mathieu-Daudé <philmd@redhat.com>
+R: Daniel P. Berrange <berrange@redhat.com>
+R: Kashyap Chamarthy <kchamart@redhat.com>
+S: Maintained
+F: docs/interop/firmware.json
+
EDK2 Firmware
M: Laszlo Ersek <lersek@redhat.com>
M: Philippe Mathieu-Daudé <philmd@redhat.com>
diff --git a/accel/tcg/translate-all.c b/accel/tcg/translate-all.c
index 2afa46b..2d83013 100644
--- a/accel/tcg/translate-all.c
+++ b/accel/tcg/translate-all.c
@@ -976,7 +976,12 @@
{
/* Size the buffer. */
if (tb_size == 0) {
- tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
+ size_t phys_mem = qemu_get_host_physmem();
+ if (phys_mem == 0) {
+ tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE;
+ } else {
+ tb_size = MIN(DEFAULT_CODE_GEN_BUFFER_SIZE, phys_mem / 8);
+ }
}
if (tb_size < MIN_CODE_GEN_BUFFER_SIZE) {
tb_size = MIN_CODE_GEN_BUFFER_SIZE;
diff --git a/block/amend.c b/block/amend.c
index f4612dc..392df9e 100644
--- a/block/amend.c
+++ b/block/amend.c
@@ -69,8 +69,12 @@
BlockdevAmendJob *s;
const char *fmt = BlockdevDriver_str(options->driver);
BlockDriver *drv = bdrv_find_format(fmt);
- BlockDriverState *bs = bdrv_find_node(node_name);
+ BlockDriverState *bs;
+ bs = bdrv_lookup_bs(NULL, node_name, errp);
+ if (!bs) {
+ return;
+ }
if (!drv) {
error_setg(errp, "Block driver '%s' not found or not supported", fmt);
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
index d315db1..53f16bd 100644
--- a/contrib/libvhost-user/libvhost-user.c
+++ b/contrib/libvhost-user/libvhost-user.c
@@ -2074,7 +2074,7 @@
/* If their number is silly, that's a fatal mistake. */
if (*head >= vq->vring.num) {
- vu_panic(dev, "Guest says index %u is available", head);
+ vu_panic(dev, "Guest says index %u is available", *head);
return false;
}
@@ -2133,7 +2133,7 @@
smp_wmb();
if (*next >= max) {
- vu_panic(dev, "Desc next is %u", next);
+ vu_panic(dev, "Desc next is %u", *next);
return VIRTQUEUE_READ_DESC_ERROR;
}
diff --git a/hw/core/machine.c b/hw/core/machine.c
index 2f881d6..8d1a90c 100644
--- a/hw/core/machine.c
+++ b/hw/core/machine.c
@@ -29,6 +29,7 @@
#include "migration/vmstate.h"
GlobalProperty hw_compat_5_0[] = {
+ { "pci-host-bridge", "x-config-reg-migration-enabled", "off" },
{ "virtio-balloon-device", "page-poison", "false" },
{ "vmport", "x-read-set-eax", "off" },
{ "vmport", "x-signal-unsupported-cmd", "off" },
diff --git a/hw/i386/pc.c b/hw/i386/pc.c
index 3d419d5..47c5ca3 100644
--- a/hw/i386/pc.c
+++ b/hw/i386/pc.c
@@ -97,7 +97,8 @@
#include "fw_cfg.h"
#include "trace.h"
-GlobalProperty pc_compat_5_0[] = {};
+GlobalProperty pc_compat_5_0[] = {
+};
const size_t pc_compat_5_0_len = G_N_ELEMENTS(pc_compat_5_0);
GlobalProperty pc_compat_4_2[] = {
diff --git a/hw/pci/pci_host.c b/hw/pci/pci_host.c
index ce7bcdb..8ca5fad 100644
--- a/hw/pci/pci_host.c
+++ b/hw/pci/pci_host.c
@@ -22,8 +22,10 @@
#include "hw/pci/pci.h"
#include "hw/pci/pci_bridge.h"
#include "hw/pci/pci_host.h"
+#include "hw/qdev-properties.h"
#include "qemu/module.h"
#include "hw/pci/pci_bus.h"
+#include "migration/vmstate.h"
#include "trace.h"
/* debug PCI */
@@ -200,12 +202,43 @@
.endianness = DEVICE_BIG_ENDIAN,
};
+static bool pci_host_needed(void *opaque)
+{
+ PCIHostState *s = opaque;
+ return s->mig_enabled;
+}
+
+const VMStateDescription vmstate_pcihost = {
+ .name = "PCIHost",
+ .needed = pci_host_needed,
+ .version_id = 1,
+ .minimum_version_id = 1,
+ .fields = (VMStateField[]) {
+ VMSTATE_UINT32(config_reg, PCIHostState),
+ VMSTATE_END_OF_LIST()
+ }
+};
+
+static Property pci_host_properties_common[] = {
+ DEFINE_PROP_BOOL("x-config-reg-migration-enabled", PCIHostState,
+ mig_enabled, true),
+ DEFINE_PROP_END_OF_LIST(),
+};
+
+static void pci_host_class_init(ObjectClass *klass, void *data)
+{
+ DeviceClass *dc = DEVICE_CLASS(klass);
+ device_class_set_props(dc, pci_host_properties_common);
+ dc->vmsd = &vmstate_pcihost;
+}
+
static const TypeInfo pci_host_type_info = {
.name = TYPE_PCI_HOST_BRIDGE,
.parent = TYPE_SYS_BUS_DEVICE,
.abstract = true,
.class_size = sizeof(PCIHostBridgeClass),
.instance_size = sizeof(PCIHostState),
+ .class_init = pci_host_class_init,
};
static void pci_host_register_types(void)
diff --git a/hw/s390x/ipl.c b/hw/s390x/ipl.c
index d46b1f0..3d2652d 100644
--- a/hw/s390x/ipl.c
+++ b/hw/s390x/ipl.c
@@ -630,7 +630,8 @@
}
}
if (reset_type == S390_RESET_MODIFIED_CLEAR ||
- reset_type == S390_RESET_LOAD_NORMAL) {
+ reset_type == S390_RESET_LOAD_NORMAL ||
+ reset_type == S390_RESET_PV) {
/* ignore -no-reboot, send no event */
qemu_system_reset_request(SHUTDOWN_CAUSE_SUBSYSTEM_RESET);
} else {
diff --git a/hw/s390x/s390-virtio-ccw.c b/hw/s390x/s390-virtio-ccw.c
index 8cc2f25..403d30e 100644
--- a/hw/s390x/s390-virtio-ccw.c
+++ b/hw/s390x/s390-virtio-ccw.c
@@ -701,8 +701,12 @@
static char *machine_get_loadparm(Object *obj, Error **errp)
{
S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
+ char *loadparm_str;
- return g_memdup(ms->loadparm, sizeof(ms->loadparm));
+ /* make a NUL-terminated string */
+ loadparm_str = g_memdup(ms->loadparm, sizeof(ms->loadparm) + 1);
+ loadparm_str[sizeof(ms->loadparm)] = 0;
+ return loadparm_str;
}
static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
diff --git a/hw/semihosting/console.c b/hw/semihosting/console.c
index 22e7827..9b4fee9 100644
--- a/hw/semihosting/console.c
+++ b/hw/semihosting/console.c
@@ -52,7 +52,9 @@
do {
if (cpu_memory_rw_debug(cpu, addr++, &c, 1, 0) == 0) {
- s = g_string_append_c(s, c);
+ if (c) {
+ s = g_string_append_c(s, c);
+ }
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: passed inaccessible address " TARGET_FMT_lx,
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index 3123121..d7e2423 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -672,7 +672,7 @@
memmove(&u->shadow_regions[shadow_reg_idx],
&u->shadow_regions[shadow_reg_idx + 1],
sizeof(struct vhost_memory_region) *
- (u->num_shadow_regions - shadow_reg_idx));
+ (u->num_shadow_regions - shadow_reg_idx - 1));
u->num_shadow_regions--;
}
diff --git a/hw/virtio/vhost-vdpa.c b/hw/virtio/vhost-vdpa.c
index 65d5aaf..4580f3e 100644
--- a/hw/virtio/vhost-vdpa.c
+++ b/hw/virtio/vhost-vdpa.c
@@ -37,7 +37,7 @@
static int vhost_vdpa_dma_map(struct vhost_vdpa *v, hwaddr iova, hwaddr size,
void *vaddr, bool readonly)
{
- struct vhost_msg_v2 msg;
+ struct vhost_msg_v2 msg = {};
int fd = v->device_fd;
int ret = 0;
@@ -60,7 +60,7 @@
static int vhost_vdpa_dma_unmap(struct vhost_vdpa *v, hwaddr iova,
hwaddr size)
{
- struct vhost_msg_v2 msg;
+ struct vhost_msg_v2 msg = {};
int fd = v->device_fd;
int ret = 0;
diff --git a/hw/virtio/virtio-mem-pci.c b/hw/virtio/virtio-mem-pci.c
index d375280..590cec0 100644
--- a/hw/virtio/virtio-mem-pci.c
+++ b/hw/virtio/virtio-mem-pci.c
@@ -21,8 +21,8 @@
VirtIOMEMPCI *mem_pci = VIRTIO_MEM_PCI(vpci_dev);
DeviceState *vdev = DEVICE(&mem_pci->vdev);
- qdev_set_parent_bus(vdev, BUS(&vpci_dev->bus));
- object_property_set_bool(OBJECT(vdev), "realized", true, errp);
+ virtio_pci_force_virtio_1(vpci_dev);
+ qdev_realize(vdev, BUS(&vpci_dev->bus), errp);
}
static void virtio_mem_pci_set_addr(MemoryDeviceState *md, uint64_t addr,
diff --git a/hw/virtio/virtio-pci.c b/hw/virtio/virtio-pci.c
index ada1101..4ad3ad8 100644
--- a/hw/virtio/virtio-pci.c
+++ b/hw/virtio/virtio-pci.c
@@ -1116,7 +1116,7 @@
return proxy->vqs[vdev->queue_sel].enabled;
}
- return virtio_queue_enabled(vdev, n);
+ return virtio_queue_enabled_legacy(vdev, n);
}
static int virtio_pci_add_mem_cap(VirtIOPCIProxy *proxy,
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index 546a198..e983025 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -3309,6 +3309,11 @@
return vdev->vq[n].vring.desc;
}
+bool virtio_queue_enabled_legacy(VirtIODevice *vdev, int n)
+{
+ return virtio_queue_get_desc_addr(vdev, n) != 0;
+}
+
bool virtio_queue_enabled(VirtIODevice *vdev, int n)
{
BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
@@ -3317,7 +3322,7 @@
if (k->queue_enabled) {
return k->queue_enabled(qbus->parent, n);
}
- return virtio_queue_get_desc_addr(vdev, n) != 0;
+ return virtio_queue_enabled_legacy(vdev, n);
}
hwaddr virtio_queue_get_avail_addr(VirtIODevice *vdev, int n)
diff --git a/include/fpu/softfloat.h b/include/fpu/softfloat.h
index f1a19df..659218b 100644
--- a/include/fpu/softfloat.h
+++ b/include/fpu/softfloat.h
@@ -822,6 +822,7 @@
}
#define floatx80_zero make_floatx80(0x0000, 0x0000000000000000LL)
+#define floatx80_zero_init make_floatx80_init(0x0000, 0x0000000000000000LL)
#define floatx80_one make_floatx80(0x3fff, 0x8000000000000000LL)
#define floatx80_ln2 make_floatx80(0x3ffe, 0xb17217f7d1cf79acLL)
#define floatx80_pi make_floatx80(0x4000, 0xc90fdaa22168c235LL)
diff --git a/include/hw/pci/pci_host.h b/include/hw/pci/pci_host.h
index 9ce088b..6210a7e 100644
--- a/include/hw/pci/pci_host.h
+++ b/include/hw/pci/pci_host.h
@@ -45,6 +45,7 @@
MemoryRegion data_mem;
MemoryRegion mmcfg;
uint32_t config_reg;
+ bool mig_enabled;
PCIBus *bus;
QLIST_ENTRY(PCIHostState) next;
diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
index 198ffc7..e424df1 100644
--- a/include/hw/virtio/virtio.h
+++ b/include/hw/virtio/virtio.h
@@ -295,6 +295,7 @@
VIRTIO_F_RING_PACKED, false)
hwaddr virtio_queue_get_desc_addr(VirtIODevice *vdev, int n);
+bool virtio_queue_enabled_legacy(VirtIODevice *vdev, int n);
bool virtio_queue_enabled(VirtIODevice *vdev, int n);
hwaddr virtio_queue_get_avail_addr(VirtIODevice *vdev, int n);
hwaddr virtio_queue_get_used_addr(VirtIODevice *vdev, int n);
diff --git a/include/qemu/osdep.h b/include/qemu/osdep.h
index 45c217a..20872e7 100644
--- a/include/qemu/osdep.h
+++ b/include/qemu/osdep.h
@@ -173,6 +173,9 @@
#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
#endif
+#ifndef MAP_FIXED_NOREPLACE
+#define MAP_FIXED_NOREPLACE 0
+#endif
#ifndef ENOMEDIUM
#define ENOMEDIUM ENODEV
#endif
@@ -668,4 +671,16 @@
*/
char *qemu_get_host_name(Error **errp);
+/**
+ * qemu_get_host_physmem:
+ *
+ * Operating system agnostic way of querying host memory.
+ *
+ * Returns amount of physical memory on the system. This is purely
+ * advisery and may return 0 if we can't work it out. At the other
+ * end we saturate to SIZE_MAX if you are lucky enough to have that
+ * much memory.
+ */
+size_t qemu_get_host_physmem(void);
+
#endif
diff --git a/linux-user/elfload.c b/linux-user/elfload.c
index 7e7f642..fe9dfe7 100644
--- a/linux-user/elfload.c
+++ b/linux-user/elfload.c
@@ -2134,12 +2134,15 @@
/* we have run out of space */
return -1;
} else {
- int flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE | MAP_FIXED;
+ int flags = MAP_ANONYMOUS | MAP_PRIVATE | MAP_NORESERVE |
+ MAP_FIXED_NOREPLACE;
void * mmap_start = mmap((void *) align_start, guest_size,
PROT_NONE, flags, -1, 0);
if (mmap_start != MAP_FAILED) {
munmap((void *) align_start, guest_size);
- return (uintptr_t) mmap_start + offset;
+ if (MAP_FIXED_NOREPLACE || mmap_start == (void *) align_start) {
+ return (uintptr_t) mmap_start + offset;
+ }
}
base += qemu_host_page_size;
}
@@ -2307,9 +2310,8 @@
/* Widen the "image" to the entire reserved address space. */
pgb_static(image_name, 0, reserved_va, align);
-#ifdef MAP_FIXED_NOREPLACE
+ /* osdep.h defines this as 0 if it's missing */
flags |= MAP_FIXED_NOREPLACE;
-#endif
/* Reserve the memory on the host. */
assert(guest_base != 0);
diff --git a/linux-user/syscall.c b/linux-user/syscall.c
index 1211e75..f5c4f6b 100644
--- a/linux-user/syscall.c
+++ b/linux-user/syscall.c
@@ -11831,16 +11831,15 @@
target_to_host_timespec(&ts, arg3);
ret = get_errno(safe_clock_nanosleep(arg1, arg2,
&ts, arg4 ? &ts : NULL));
- if (arg4)
+ /*
+ * if the call is interrupted by a signal handler, it fails
+ * with error -TARGET_EINTR and if arg4 is not NULL and arg2 is not
+ * TIMER_ABSTIME, it returns the remaining unslept time in arg4.
+ */
+ if (ret == -TARGET_EINTR && arg4 && arg2 != TIMER_ABSTIME) {
host_to_target_timespec(arg4, &ts);
-
-#if defined(TARGET_PPC)
- /* clock_nanosleep is odd in that it returns positive errno values.
- * On PPC, CR0 bit 3 should be set in such a situation. */
- if (ret && ret != -TARGET_ERESTARTSYS) {
- ((CPUPPCState *)cpu_env)->crf[0] |= 1;
}
-#endif
+
return ret;
}
#endif
diff --git a/python/qemu/console_socket.py b/python/qemu/console_socket.py
index 830cb7c..70869fb 100644
--- a/python/qemu/console_socket.py
+++ b/python/qemu/console_socket.py
@@ -1,12 +1,9 @@
-#!/usr/bin/env python3
-#
-# This python module implements a ConsoleSocket object which is
-# designed always drain the socket itself, and place
-# the bytes into a in memory buffer for later processing.
-#
-# Optionally a file path can be passed in and we will also
-# dump the characters to this file for debug.
-#
+"""
+QEMU Console Socket Module:
+
+This python module implements a ConsoleSocket object,
+which can drain a socket and optionally dump the bytes to file.
+"""
# Copyright 2020 Linaro
#
# Authors:
@@ -15,96 +12,118 @@
# This code is licensed under the GPL version 2 or later. See
# the COPYING file in the top-level directory.
#
-import asyncore
+
import socket
import threading
-import io
-import os
-import sys
from collections import deque
import time
-import traceback
-class ConsoleSocket(asyncore.dispatcher):
- def __init__(self, address, file=None):
+class ConsoleSocket(socket.socket):
+ """
+ ConsoleSocket represents a socket attached to a char device.
+
+ Optionally (if drain==True), drains the socket and places the bytes
+ into an in memory buffer for later processing.
+
+ Optionally a file path can be passed in and we will also
+ dump the characters to this file for debugging purposes.
+ """
+ def __init__(self, address, file=None, drain=False):
self._recv_timeout_sec = 300
+ self._sleep_time = 0.5
self._buffer = deque()
- self._asyncore_thread = None
- self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
- self._sock.connect(address)
+ socket.socket.__init__(self, socket.AF_UNIX, socket.SOCK_STREAM)
+ self.connect(address)
self._logfile = None
if file:
self._logfile = open(file, "w")
- asyncore.dispatcher.__init__(self, sock=self._sock)
self._open = True
- self._thread_start()
+ if drain:
+ self._drain_thread = self._thread_start()
+ else:
+ self._drain_thread = None
+
+ def _drain_fn(self):
+ """Drains the socket and runs while the socket is open."""
+ while self._open:
+ try:
+ self._drain_socket()
+ except socket.timeout:
+ # The socket is expected to timeout since we set a
+ # short timeout to allow the thread to exit when
+ # self._open is set to False.
+ time.sleep(self._sleep_time)
def _thread_start(self):
- """Kick off a thread to wait on the asyncore.loop"""
- if self._asyncore_thread is not None:
- return
- self._asyncore_thread = threading.Thread(target=asyncore.loop,
- kwargs={'timeout':1})
- self._asyncore_thread.daemon = True
- self._asyncore_thread.start()
-
- def handle_close(self):
- """redirect close to base class"""
- # Call the base class close, but not self.close() since
- # handle_close() occurs in the context of the thread which
- # self.close() attempts to join.
- asyncore.dispatcher.close(self)
+ """Kick off a thread to drain the socket."""
+ # Configure socket to not block and timeout.
+ # This allows our drain thread to not block
+ # on recieve and exit smoothly.
+ socket.socket.setblocking(self, False)
+ socket.socket.settimeout(self, 1)
+ drain_thread = threading.Thread(target=self._drain_fn)
+ drain_thread.daemon = True
+ drain_thread.start()
+ return drain_thread
def close(self):
"""Close the base object and wait for the thread to terminate"""
if self._open:
self._open = False
- asyncore.dispatcher.close(self)
- if self._asyncore_thread is not None:
- thread, self._asyncore_thread = self._asyncore_thread, None
+ if self._drain_thread is not None:
+ thread, self._drain_thread = self._drain_thread, None
thread.join()
+ socket.socket.close(self)
if self._logfile:
self._logfile.close()
self._logfile = None
- def handle_read(self):
+ def _drain_socket(self):
"""process arriving characters into in memory _buffer"""
- try:
- data = asyncore.dispatcher.recv(self, 1)
- # latin1 is needed since there are some chars
- # we are receiving that cannot be encoded to utf-8
- # such as 0xe2, 0x80, 0xA6.
- string = data.decode("latin1")
- except:
- print("Exception seen.")
- traceback.print_exc()
- return
+ data = socket.socket.recv(self, 1)
+ # latin1 is needed since there are some chars
+ # we are receiving that cannot be encoded to utf-8
+ # such as 0xe2, 0x80, 0xA6.
+ string = data.decode("latin1")
if self._logfile:
self._logfile.write("{}".format(string))
self._logfile.flush()
for c in string:
self._buffer.extend(c)
- def recv(self, n=1, sleep_delay_s=0.1):
- """Return chars from in memory buffer"""
+ def recv(self, bufsize=1):
+ """Return chars from in memory buffer.
+ Maintains the same API as socket.socket.recv.
+ """
+ if self._drain_thread is None:
+ # Not buffering the socket, pass thru to socket.
+ return socket.socket.recv(self, bufsize)
start_time = time.time()
- while len(self._buffer) < n:
- time.sleep(sleep_delay_s)
+ while len(self._buffer) < bufsize:
+ time.sleep(self._sleep_time)
elapsed_sec = time.time() - start_time
if elapsed_sec > self._recv_timeout_sec:
raise socket.timeout
- chars = ''.join([self._buffer.popleft() for i in range(n)])
+ chars = ''.join([self._buffer.popleft() for i in range(bufsize)])
# We choose to use latin1 to remain consistent with
# handle_read() and give back the same data as the user would
# receive if they were reading directly from the
# socket w/o our intervention.
return chars.encode("latin1")
- def set_blocking(self):
- """Maintain compatibility with socket API"""
- pass
+ def setblocking(self, value):
+ """When not draining we pass thru to the socket,
+ since when draining we control socket blocking.
+ """
+ if self._drain_thread is None:
+ socket.socket.setblocking(self, value)
def settimeout(self, seconds):
- """Set current timeout on recv"""
- self._recv_timeout_sec = seconds
+ """When not draining we pass thru to the socket,
+ since when draining we control the timeout.
+ """
+ if seconds is not None:
+ self._recv_timeout_sec = seconds
+ if self._drain_thread is None:
+ socket.socket.settimeout(self, seconds)
diff --git a/python/qemu/machine.py b/python/qemu/machine.py
index 51aa255..82f3731 100644
--- a/python/qemu/machine.py
+++ b/python/qemu/machine.py
@@ -23,11 +23,10 @@
import subprocess
import shutil
import signal
-import socket
import tempfile
from typing import Optional, Type
from types import TracebackType
-from qemu.console_socket import ConsoleSocket
+from . import console_socket
from . import qmp
@@ -673,11 +672,8 @@
Returns a socket connected to the console
"""
if self._console_socket is None:
- if self._drain_console:
- self._console_socket = ConsoleSocket(self._console_address,
- file=self._console_log_path)
- else:
- self._console_socket = socket.socket(socket.AF_UNIX,
- socket.SOCK_STREAM)
- self._console_socket.connect(self._console_address)
+ self._console_socket = console_socket.ConsoleSocket(
+ self._console_address,
+ file=self._console_log_path,
+ drain=self._drain_console)
return self._console_socket
diff --git a/python/qemu/pylintrc b/python/qemu/pylintrc
index 5d6ae73..3f69205 100644
--- a/python/qemu/pylintrc
+++ b/python/qemu/pylintrc
@@ -33,7 +33,7 @@
Run,
_,
fd,
-
+ c,
[VARIABLES]
[STRING]
diff --git a/softmmu/vl.c b/softmmu/vl.c
index 660537a..4eb9d1f 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -4127,8 +4127,6 @@
qemu_opts_foreach(qemu_find_opts("chardev"),
chardev_init_func, NULL, &error_fatal);
- /* now chardevs have been created we may have semihosting to connect */
- qemu_semihosting_connect_chardevs();
#ifdef CONFIG_VIRTFS
qemu_opts_foreach(qemu_find_opts("fsdev"),
@@ -4279,6 +4277,9 @@
if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
exit(1);
+ /* now chardevs have been created we may have semihosting to connect */
+ qemu_semihosting_connect_chardevs();
+
/* If no default VGA is requested, the default is "none". */
if (default_vga) {
vga_model = get_default_vga_model(machine_class);
diff --git a/target/i386/fpu_helper.c b/target/i386/fpu_helper.c
index f5e6c4b..4ea7387 100644
--- a/target/i386/fpu_helper.c
+++ b/target/i386/fpu_helper.c
@@ -868,201 +868,201 @@
};
static const struct f2xm1_data f2xm1_table[65] = {
- { make_floatx80(0xbfff, 0x8000000000000000ULL),
- make_floatx80(0x3ffe, 0x8000000000000000ULL),
- make_floatx80(0xbffe, 0x8000000000000000ULL) },
- { make_floatx80(0xbffe, 0xf800000000002e7eULL),
- make_floatx80(0x3ffe, 0x82cd8698ac2b9160ULL),
- make_floatx80(0xbffd, 0xfa64f2cea7a8dd40ULL) },
- { make_floatx80(0xbffe, 0xefffffffffffe960ULL),
- make_floatx80(0x3ffe, 0x85aac367cc488345ULL),
- make_floatx80(0xbffd, 0xf4aa7930676ef976ULL) },
- { make_floatx80(0xbffe, 0xe800000000006f10ULL),
- make_floatx80(0x3ffe, 0x88980e8092da5c14ULL),
- make_floatx80(0xbffd, 0xeecfe2feda4b47d8ULL) },
- { make_floatx80(0xbffe, 0xe000000000008a45ULL),
- make_floatx80(0x3ffe, 0x8b95c1e3ea8ba2a5ULL),
- make_floatx80(0xbffd, 0xe8d47c382ae8bab6ULL) },
- { make_floatx80(0xbffe, 0xd7ffffffffff8a9eULL),
- make_floatx80(0x3ffe, 0x8ea4398b45cd8116ULL),
- make_floatx80(0xbffd, 0xe2b78ce97464fdd4ULL) },
- { make_floatx80(0xbffe, 0xd0000000000019a0ULL),
- make_floatx80(0x3ffe, 0x91c3d373ab11b919ULL),
- make_floatx80(0xbffd, 0xdc785918a9dc8dceULL) },
- { make_floatx80(0xbffe, 0xc7ffffffffff14dfULL),
- make_floatx80(0x3ffe, 0x94f4efa8fef76836ULL),
- make_floatx80(0xbffd, 0xd61620ae02112f94ULL) },
- { make_floatx80(0xbffe, 0xc000000000006530ULL),
- make_floatx80(0x3ffe, 0x9837f0518db87fbbULL),
- make_floatx80(0xbffd, 0xcf901f5ce48f008aULL) },
- { make_floatx80(0xbffe, 0xb7ffffffffff1723ULL),
- make_floatx80(0x3ffe, 0x9b8d39b9d54eb74cULL),
- make_floatx80(0xbffd, 0xc8e58c8c55629168ULL) },
- { make_floatx80(0xbffe, 0xb00000000000b5e1ULL),
- make_floatx80(0x3ffe, 0x9ef5326091a0c366ULL),
- make_floatx80(0xbffd, 0xc2159b3edcbe7934ULL) },
- { make_floatx80(0xbffe, 0xa800000000006f8aULL),
- make_floatx80(0x3ffe, 0xa27043030c49370aULL),
- make_floatx80(0xbffd, 0xbb1f79f9e76d91ecULL) },
- { make_floatx80(0xbffe, 0x9fffffffffff816aULL),
- make_floatx80(0x3ffe, 0xa5fed6a9b15171cfULL),
- make_floatx80(0xbffd, 0xb40252ac9d5d1c62ULL) },
- { make_floatx80(0xbffe, 0x97ffffffffffb621ULL),
- make_floatx80(0x3ffe, 0xa9a15ab4ea7c30e6ULL),
- make_floatx80(0xbffd, 0xacbd4a962b079e34ULL) },
- { make_floatx80(0xbffe, 0x8fffffffffff162bULL),
- make_floatx80(0x3ffe, 0xad583eea42a1b886ULL),
- make_floatx80(0xbffd, 0xa54f822b7abc8ef4ULL) },
- { make_floatx80(0xbffe, 0x87ffffffffff4d34ULL),
- make_floatx80(0x3ffe, 0xb123f581d2ac7b51ULL),
- make_floatx80(0xbffd, 0x9db814fc5aa7095eULL) },
- { make_floatx80(0xbffe, 0x800000000000227dULL),
- make_floatx80(0x3ffe, 0xb504f333f9de539dULL),
- make_floatx80(0xbffd, 0x95f619980c4358c6ULL) },
- { make_floatx80(0xbffd, 0xefffffffffff3978ULL),
- make_floatx80(0x3ffe, 0xb8fbaf4762fbd0a1ULL),
- make_floatx80(0xbffd, 0x8e08a1713a085ebeULL) },
- { make_floatx80(0xbffd, 0xe00000000000df81ULL),
- make_floatx80(0x3ffe, 0xbd08a39f580bfd8cULL),
- make_floatx80(0xbffd, 0x85eeb8c14fe804e8ULL) },
- { make_floatx80(0xbffd, 0xd00000000000bccfULL),
- make_floatx80(0x3ffe, 0xc12c4cca667062f6ULL),
- make_floatx80(0xbffc, 0xfb4eccd6663e7428ULL) },
- { make_floatx80(0xbffd, 0xc00000000000eff0ULL),
- make_floatx80(0x3ffe, 0xc5672a1155069abeULL),
- make_floatx80(0xbffc, 0xea6357baabe59508ULL) },
- { make_floatx80(0xbffd, 0xb000000000000fe6ULL),
- make_floatx80(0x3ffe, 0xc9b9bd866e2f234bULL),
- make_floatx80(0xbffc, 0xd91909e6474372d4ULL) },
- { make_floatx80(0xbffd, 0x9fffffffffff2172ULL),
- make_floatx80(0x3ffe, 0xce248c151f84bf00ULL),
- make_floatx80(0xbffc, 0xc76dcfab81ed0400ULL) },
- { make_floatx80(0xbffd, 0x8fffffffffffafffULL),
- make_floatx80(0x3ffe, 0xd2a81d91f12afb2bULL),
- make_floatx80(0xbffc, 0xb55f89b83b541354ULL) },
- { make_floatx80(0xbffc, 0xffffffffffff81a3ULL),
- make_floatx80(0x3ffe, 0xd744fccad69d7d5eULL),
- make_floatx80(0xbffc, 0xa2ec0cd4a58a0a88ULL) },
- { make_floatx80(0xbffc, 0xdfffffffffff1568ULL),
- make_floatx80(0x3ffe, 0xdbfbb797daf25a44ULL),
- make_floatx80(0xbffc, 0x901121a0943696f0ULL) },
- { make_floatx80(0xbffc, 0xbfffffffffff68daULL),
- make_floatx80(0x3ffe, 0xe0ccdeec2a94f811ULL),
- make_floatx80(0xbffb, 0xf999089eab583f78ULL) },
- { make_floatx80(0xbffc, 0x9fffffffffff4690ULL),
- make_floatx80(0x3ffe, 0xe5b906e77c83657eULL),
- make_floatx80(0xbffb, 0xd237c8c41be4d410ULL) },
- { make_floatx80(0xbffb, 0xffffffffffff8aeeULL),
- make_floatx80(0x3ffe, 0xeac0c6e7dd24427cULL),
- make_floatx80(0xbffb, 0xa9f9c8c116ddec20ULL) },
- { make_floatx80(0xbffb, 0xbfffffffffff2d18ULL),
- make_floatx80(0x3ffe, 0xefe4b99bdcdb06ebULL),
- make_floatx80(0xbffb, 0x80da33211927c8a8ULL) },
- { make_floatx80(0xbffa, 0xffffffffffff8ccbULL),
- make_floatx80(0x3ffe, 0xf5257d152486d0f4ULL),
- make_floatx80(0xbffa, 0xada82eadb792f0c0ULL) },
- { make_floatx80(0xbff9, 0xffffffffffff11feULL),
- make_floatx80(0x3ffe, 0xfa83b2db722a0846ULL),
- make_floatx80(0xbff9, 0xaf89a491babef740ULL) },
- { floatx80_zero,
- make_floatx80(0x3fff, 0x8000000000000000ULL),
- floatx80_zero },
- { make_floatx80(0x3ff9, 0xffffffffffff2680ULL),
- make_floatx80(0x3fff, 0x82cd8698ac2b9f6fULL),
- make_floatx80(0x3ff9, 0xb361a62b0ae7dbc0ULL) },
- { make_floatx80(0x3ffb, 0x800000000000b500ULL),
- make_floatx80(0x3fff, 0x85aac367cc488345ULL),
- make_floatx80(0x3ffa, 0xb5586cf9891068a0ULL) },
- { make_floatx80(0x3ffb, 0xbfffffffffff4b67ULL),
- make_floatx80(0x3fff, 0x88980e8092da7cceULL),
- make_floatx80(0x3ffb, 0x8980e8092da7cce0ULL) },
- { make_floatx80(0x3ffb, 0xffffffffffffff57ULL),
- make_floatx80(0x3fff, 0x8b95c1e3ea8bd6dfULL),
- make_floatx80(0x3ffb, 0xb95c1e3ea8bd6df0ULL) },
- { make_floatx80(0x3ffc, 0x9fffffffffff811fULL),
- make_floatx80(0x3fff, 0x8ea4398b45cd4780ULL),
- make_floatx80(0x3ffb, 0xea4398b45cd47800ULL) },
- { make_floatx80(0x3ffc, 0xbfffffffffff9980ULL),
- make_floatx80(0x3fff, 0x91c3d373ab11b919ULL),
- make_floatx80(0x3ffc, 0x8e1e9b9d588dc8c8ULL) },
- { make_floatx80(0x3ffc, 0xdffffffffffff631ULL),
- make_floatx80(0x3fff, 0x94f4efa8fef70864ULL),
- make_floatx80(0x3ffc, 0xa7a77d47f7b84320ULL) },
- { make_floatx80(0x3ffc, 0xffffffffffff2499ULL),
- make_floatx80(0x3fff, 0x9837f0518db892d4ULL),
- make_floatx80(0x3ffc, 0xc1bf828c6dc496a0ULL) },
- { make_floatx80(0x3ffd, 0x8fffffffffff80fbULL),
- make_floatx80(0x3fff, 0x9b8d39b9d54e3a79ULL),
- make_floatx80(0x3ffc, 0xdc69cdceaa71d3c8ULL) },
- { make_floatx80(0x3ffd, 0x9fffffffffffbc23ULL),
- make_floatx80(0x3fff, 0x9ef5326091a10313ULL),
- make_floatx80(0x3ffc, 0xf7a993048d081898ULL) },
- { make_floatx80(0x3ffd, 0xafffffffffff20ecULL),
- make_floatx80(0x3fff, 0xa27043030c49370aULL),
- make_floatx80(0x3ffd, 0x89c10c0c3124dc28ULL) },
- { make_floatx80(0x3ffd, 0xc00000000000fd2cULL),
- make_floatx80(0x3fff, 0xa5fed6a9b15171cfULL),
- make_floatx80(0x3ffd, 0x97fb5aa6c545c73cULL) },
- { make_floatx80(0x3ffd, 0xd0000000000093beULL),
- make_floatx80(0x3fff, 0xa9a15ab4ea7c30e6ULL),
- make_floatx80(0x3ffd, 0xa6856ad3a9f0c398ULL) },
- { make_floatx80(0x3ffd, 0xe00000000000c2aeULL),
- make_floatx80(0x3fff, 0xad583eea42a17876ULL),
- make_floatx80(0x3ffd, 0xb560fba90a85e1d8ULL) },
- { make_floatx80(0x3ffd, 0xefffffffffff1e3fULL),
- make_floatx80(0x3fff, 0xb123f581d2abef6cULL),
- make_floatx80(0x3ffd, 0xc48fd6074aafbdb0ULL) },
- { make_floatx80(0x3ffd, 0xffffffffffff1c23ULL),
- make_floatx80(0x3fff, 0xb504f333f9de2cadULL),
- make_floatx80(0x3ffd, 0xd413cccfe778b2b4ULL) },
- { make_floatx80(0x3ffe, 0x8800000000006344ULL),
- make_floatx80(0x3fff, 0xb8fbaf4762fbd0a1ULL),
- make_floatx80(0x3ffd, 0xe3eebd1d8bef4284ULL) },
- { make_floatx80(0x3ffe, 0x9000000000005d67ULL),
- make_floatx80(0x3fff, 0xbd08a39f580c668dULL),
- make_floatx80(0x3ffd, 0xf4228e7d60319a34ULL) },
- { make_floatx80(0x3ffe, 0x9800000000009127ULL),
- make_floatx80(0x3fff, 0xc12c4cca6670e042ULL),
- make_floatx80(0x3ffe, 0x82589994cce1c084ULL) },
- { make_floatx80(0x3ffe, 0x9fffffffffff06f9ULL),
- make_floatx80(0x3fff, 0xc5672a11550655c3ULL),
- make_floatx80(0x3ffe, 0x8ace5422aa0cab86ULL) },
- { make_floatx80(0x3ffe, 0xa7fffffffffff80dULL),
- make_floatx80(0x3fff, 0xc9b9bd866e2f234bULL),
- make_floatx80(0x3ffe, 0x93737b0cdc5e4696ULL) },
- { make_floatx80(0x3ffe, 0xafffffffffff1470ULL),
- make_floatx80(0x3fff, 0xce248c151f83fd69ULL),
- make_floatx80(0x3ffe, 0x9c49182a3f07fad2ULL) },
- { make_floatx80(0x3ffe, 0xb800000000000e0aULL),
- make_floatx80(0x3fff, 0xd2a81d91f12aec5cULL),
- make_floatx80(0x3ffe, 0xa5503b23e255d8b8ULL) },
- { make_floatx80(0x3ffe, 0xc00000000000b7faULL),
- make_floatx80(0x3fff, 0xd744fccad69dd630ULL),
- make_floatx80(0x3ffe, 0xae89f995ad3bac60ULL) },
- { make_floatx80(0x3ffe, 0xc800000000003aa6ULL),
- make_floatx80(0x3fff, 0xdbfbb797daf25a44ULL),
- make_floatx80(0x3ffe, 0xb7f76f2fb5e4b488ULL) },
- { make_floatx80(0x3ffe, 0xd00000000000a6aeULL),
- make_floatx80(0x3fff, 0xe0ccdeec2a954685ULL),
- make_floatx80(0x3ffe, 0xc199bdd8552a8d0aULL) },
- { make_floatx80(0x3ffe, 0xd800000000004165ULL),
- make_floatx80(0x3fff, 0xe5b906e77c837155ULL),
- make_floatx80(0x3ffe, 0xcb720dcef906e2aaULL) },
- { make_floatx80(0x3ffe, 0xe00000000000582cULL),
- make_floatx80(0x3fff, 0xeac0c6e7dd24713aULL),
- make_floatx80(0x3ffe, 0xd5818dcfba48e274ULL) },
- { make_floatx80(0x3ffe, 0xe800000000001a5dULL),
- make_floatx80(0x3fff, 0xefe4b99bdcdb06ebULL),
- make_floatx80(0x3ffe, 0xdfc97337b9b60dd6ULL) },
- { make_floatx80(0x3ffe, 0xefffffffffffc1efULL),
- make_floatx80(0x3fff, 0xf5257d152486a2faULL),
- make_floatx80(0x3ffe, 0xea4afa2a490d45f4ULL) },
- { make_floatx80(0x3ffe, 0xf800000000001069ULL),
- make_floatx80(0x3fff, 0xfa83b2db722a0e5cULL),
- make_floatx80(0x3ffe, 0xf50765b6e4541cb8ULL) },
- { make_floatx80(0x3fff, 0x8000000000000000ULL),
- make_floatx80(0x4000, 0x8000000000000000ULL),
- make_floatx80(0x3fff, 0x8000000000000000ULL) },
+ { make_floatx80_init(0xbfff, 0x8000000000000000ULL),
+ make_floatx80_init(0x3ffe, 0x8000000000000000ULL),
+ make_floatx80_init(0xbffe, 0x8000000000000000ULL) },
+ { make_floatx80_init(0xbffe, 0xf800000000002e7eULL),
+ make_floatx80_init(0x3ffe, 0x82cd8698ac2b9160ULL),
+ make_floatx80_init(0xbffd, 0xfa64f2cea7a8dd40ULL) },
+ { make_floatx80_init(0xbffe, 0xefffffffffffe960ULL),
+ make_floatx80_init(0x3ffe, 0x85aac367cc488345ULL),
+ make_floatx80_init(0xbffd, 0xf4aa7930676ef976ULL) },
+ { make_floatx80_init(0xbffe, 0xe800000000006f10ULL),
+ make_floatx80_init(0x3ffe, 0x88980e8092da5c14ULL),
+ make_floatx80_init(0xbffd, 0xeecfe2feda4b47d8ULL) },
+ { make_floatx80_init(0xbffe, 0xe000000000008a45ULL),
+ make_floatx80_init(0x3ffe, 0x8b95c1e3ea8ba2a5ULL),
+ make_floatx80_init(0xbffd, 0xe8d47c382ae8bab6ULL) },
+ { make_floatx80_init(0xbffe, 0xd7ffffffffff8a9eULL),
+ make_floatx80_init(0x3ffe, 0x8ea4398b45cd8116ULL),
+ make_floatx80_init(0xbffd, 0xe2b78ce97464fdd4ULL) },
+ { make_floatx80_init(0xbffe, 0xd0000000000019a0ULL),
+ make_floatx80_init(0x3ffe, 0x91c3d373ab11b919ULL),
+ make_floatx80_init(0xbffd, 0xdc785918a9dc8dceULL) },
+ { make_floatx80_init(0xbffe, 0xc7ffffffffff14dfULL),
+ make_floatx80_init(0x3ffe, 0x94f4efa8fef76836ULL),
+ make_floatx80_init(0xbffd, 0xd61620ae02112f94ULL) },
+ { make_floatx80_init(0xbffe, 0xc000000000006530ULL),
+ make_floatx80_init(0x3ffe, 0x9837f0518db87fbbULL),
+ make_floatx80_init(0xbffd, 0xcf901f5ce48f008aULL) },
+ { make_floatx80_init(0xbffe, 0xb7ffffffffff1723ULL),
+ make_floatx80_init(0x3ffe, 0x9b8d39b9d54eb74cULL),
+ make_floatx80_init(0xbffd, 0xc8e58c8c55629168ULL) },
+ { make_floatx80_init(0xbffe, 0xb00000000000b5e1ULL),
+ make_floatx80_init(0x3ffe, 0x9ef5326091a0c366ULL),
+ make_floatx80_init(0xbffd, 0xc2159b3edcbe7934ULL) },
+ { make_floatx80_init(0xbffe, 0xa800000000006f8aULL),
+ make_floatx80_init(0x3ffe, 0xa27043030c49370aULL),
+ make_floatx80_init(0xbffd, 0xbb1f79f9e76d91ecULL) },
+ { make_floatx80_init(0xbffe, 0x9fffffffffff816aULL),
+ make_floatx80_init(0x3ffe, 0xa5fed6a9b15171cfULL),
+ make_floatx80_init(0xbffd, 0xb40252ac9d5d1c62ULL) },
+ { make_floatx80_init(0xbffe, 0x97ffffffffffb621ULL),
+ make_floatx80_init(0x3ffe, 0xa9a15ab4ea7c30e6ULL),
+ make_floatx80_init(0xbffd, 0xacbd4a962b079e34ULL) },
+ { make_floatx80_init(0xbffe, 0x8fffffffffff162bULL),
+ make_floatx80_init(0x3ffe, 0xad583eea42a1b886ULL),
+ make_floatx80_init(0xbffd, 0xa54f822b7abc8ef4ULL) },
+ { make_floatx80_init(0xbffe, 0x87ffffffffff4d34ULL),
+ make_floatx80_init(0x3ffe, 0xb123f581d2ac7b51ULL),
+ make_floatx80_init(0xbffd, 0x9db814fc5aa7095eULL) },
+ { make_floatx80_init(0xbffe, 0x800000000000227dULL),
+ make_floatx80_init(0x3ffe, 0xb504f333f9de539dULL),
+ make_floatx80_init(0xbffd, 0x95f619980c4358c6ULL) },
+ { make_floatx80_init(0xbffd, 0xefffffffffff3978ULL),
+ make_floatx80_init(0x3ffe, 0xb8fbaf4762fbd0a1ULL),
+ make_floatx80_init(0xbffd, 0x8e08a1713a085ebeULL) },
+ { make_floatx80_init(0xbffd, 0xe00000000000df81ULL),
+ make_floatx80_init(0x3ffe, 0xbd08a39f580bfd8cULL),
+ make_floatx80_init(0xbffd, 0x85eeb8c14fe804e8ULL) },
+ { make_floatx80_init(0xbffd, 0xd00000000000bccfULL),
+ make_floatx80_init(0x3ffe, 0xc12c4cca667062f6ULL),
+ make_floatx80_init(0xbffc, 0xfb4eccd6663e7428ULL) },
+ { make_floatx80_init(0xbffd, 0xc00000000000eff0ULL),
+ make_floatx80_init(0x3ffe, 0xc5672a1155069abeULL),
+ make_floatx80_init(0xbffc, 0xea6357baabe59508ULL) },
+ { make_floatx80_init(0xbffd, 0xb000000000000fe6ULL),
+ make_floatx80_init(0x3ffe, 0xc9b9bd866e2f234bULL),
+ make_floatx80_init(0xbffc, 0xd91909e6474372d4ULL) },
+ { make_floatx80_init(0xbffd, 0x9fffffffffff2172ULL),
+ make_floatx80_init(0x3ffe, 0xce248c151f84bf00ULL),
+ make_floatx80_init(0xbffc, 0xc76dcfab81ed0400ULL) },
+ { make_floatx80_init(0xbffd, 0x8fffffffffffafffULL),
+ make_floatx80_init(0x3ffe, 0xd2a81d91f12afb2bULL),
+ make_floatx80_init(0xbffc, 0xb55f89b83b541354ULL) },
+ { make_floatx80_init(0xbffc, 0xffffffffffff81a3ULL),
+ make_floatx80_init(0x3ffe, 0xd744fccad69d7d5eULL),
+ make_floatx80_init(0xbffc, 0xa2ec0cd4a58a0a88ULL) },
+ { make_floatx80_init(0xbffc, 0xdfffffffffff1568ULL),
+ make_floatx80_init(0x3ffe, 0xdbfbb797daf25a44ULL),
+ make_floatx80_init(0xbffc, 0x901121a0943696f0ULL) },
+ { make_floatx80_init(0xbffc, 0xbfffffffffff68daULL),
+ make_floatx80_init(0x3ffe, 0xe0ccdeec2a94f811ULL),
+ make_floatx80_init(0xbffb, 0xf999089eab583f78ULL) },
+ { make_floatx80_init(0xbffc, 0x9fffffffffff4690ULL),
+ make_floatx80_init(0x3ffe, 0xe5b906e77c83657eULL),
+ make_floatx80_init(0xbffb, 0xd237c8c41be4d410ULL) },
+ { make_floatx80_init(0xbffb, 0xffffffffffff8aeeULL),
+ make_floatx80_init(0x3ffe, 0xeac0c6e7dd24427cULL),
+ make_floatx80_init(0xbffb, 0xa9f9c8c116ddec20ULL) },
+ { make_floatx80_init(0xbffb, 0xbfffffffffff2d18ULL),
+ make_floatx80_init(0x3ffe, 0xefe4b99bdcdb06ebULL),
+ make_floatx80_init(0xbffb, 0x80da33211927c8a8ULL) },
+ { make_floatx80_init(0xbffa, 0xffffffffffff8ccbULL),
+ make_floatx80_init(0x3ffe, 0xf5257d152486d0f4ULL),
+ make_floatx80_init(0xbffa, 0xada82eadb792f0c0ULL) },
+ { make_floatx80_init(0xbff9, 0xffffffffffff11feULL),
+ make_floatx80_init(0x3ffe, 0xfa83b2db722a0846ULL),
+ make_floatx80_init(0xbff9, 0xaf89a491babef740ULL) },
+ { floatx80_zero_init,
+ make_floatx80_init(0x3fff, 0x8000000000000000ULL),
+ floatx80_zero_init },
+ { make_floatx80_init(0x3ff9, 0xffffffffffff2680ULL),
+ make_floatx80_init(0x3fff, 0x82cd8698ac2b9f6fULL),
+ make_floatx80_init(0x3ff9, 0xb361a62b0ae7dbc0ULL) },
+ { make_floatx80_init(0x3ffb, 0x800000000000b500ULL),
+ make_floatx80_init(0x3fff, 0x85aac367cc488345ULL),
+ make_floatx80_init(0x3ffa, 0xb5586cf9891068a0ULL) },
+ { make_floatx80_init(0x3ffb, 0xbfffffffffff4b67ULL),
+ make_floatx80_init(0x3fff, 0x88980e8092da7cceULL),
+ make_floatx80_init(0x3ffb, 0x8980e8092da7cce0ULL) },
+ { make_floatx80_init(0x3ffb, 0xffffffffffffff57ULL),
+ make_floatx80_init(0x3fff, 0x8b95c1e3ea8bd6dfULL),
+ make_floatx80_init(0x3ffb, 0xb95c1e3ea8bd6df0ULL) },
+ { make_floatx80_init(0x3ffc, 0x9fffffffffff811fULL),
+ make_floatx80_init(0x3fff, 0x8ea4398b45cd4780ULL),
+ make_floatx80_init(0x3ffb, 0xea4398b45cd47800ULL) },
+ { make_floatx80_init(0x3ffc, 0xbfffffffffff9980ULL),
+ make_floatx80_init(0x3fff, 0x91c3d373ab11b919ULL),
+ make_floatx80_init(0x3ffc, 0x8e1e9b9d588dc8c8ULL) },
+ { make_floatx80_init(0x3ffc, 0xdffffffffffff631ULL),
+ make_floatx80_init(0x3fff, 0x94f4efa8fef70864ULL),
+ make_floatx80_init(0x3ffc, 0xa7a77d47f7b84320ULL) },
+ { make_floatx80_init(0x3ffc, 0xffffffffffff2499ULL),
+ make_floatx80_init(0x3fff, 0x9837f0518db892d4ULL),
+ make_floatx80_init(0x3ffc, 0xc1bf828c6dc496a0ULL) },
+ { make_floatx80_init(0x3ffd, 0x8fffffffffff80fbULL),
+ make_floatx80_init(0x3fff, 0x9b8d39b9d54e3a79ULL),
+ make_floatx80_init(0x3ffc, 0xdc69cdceaa71d3c8ULL) },
+ { make_floatx80_init(0x3ffd, 0x9fffffffffffbc23ULL),
+ make_floatx80_init(0x3fff, 0x9ef5326091a10313ULL),
+ make_floatx80_init(0x3ffc, 0xf7a993048d081898ULL) },
+ { make_floatx80_init(0x3ffd, 0xafffffffffff20ecULL),
+ make_floatx80_init(0x3fff, 0xa27043030c49370aULL),
+ make_floatx80_init(0x3ffd, 0x89c10c0c3124dc28ULL) },
+ { make_floatx80_init(0x3ffd, 0xc00000000000fd2cULL),
+ make_floatx80_init(0x3fff, 0xa5fed6a9b15171cfULL),
+ make_floatx80_init(0x3ffd, 0x97fb5aa6c545c73cULL) },
+ { make_floatx80_init(0x3ffd, 0xd0000000000093beULL),
+ make_floatx80_init(0x3fff, 0xa9a15ab4ea7c30e6ULL),
+ make_floatx80_init(0x3ffd, 0xa6856ad3a9f0c398ULL) },
+ { make_floatx80_init(0x3ffd, 0xe00000000000c2aeULL),
+ make_floatx80_init(0x3fff, 0xad583eea42a17876ULL),
+ make_floatx80_init(0x3ffd, 0xb560fba90a85e1d8ULL) },
+ { make_floatx80_init(0x3ffd, 0xefffffffffff1e3fULL),
+ make_floatx80_init(0x3fff, 0xb123f581d2abef6cULL),
+ make_floatx80_init(0x3ffd, 0xc48fd6074aafbdb0ULL) },
+ { make_floatx80_init(0x3ffd, 0xffffffffffff1c23ULL),
+ make_floatx80_init(0x3fff, 0xb504f333f9de2cadULL),
+ make_floatx80_init(0x3ffd, 0xd413cccfe778b2b4ULL) },
+ { make_floatx80_init(0x3ffe, 0x8800000000006344ULL),
+ make_floatx80_init(0x3fff, 0xb8fbaf4762fbd0a1ULL),
+ make_floatx80_init(0x3ffd, 0xe3eebd1d8bef4284ULL) },
+ { make_floatx80_init(0x3ffe, 0x9000000000005d67ULL),
+ make_floatx80_init(0x3fff, 0xbd08a39f580c668dULL),
+ make_floatx80_init(0x3ffd, 0xf4228e7d60319a34ULL) },
+ { make_floatx80_init(0x3ffe, 0x9800000000009127ULL),
+ make_floatx80_init(0x3fff, 0xc12c4cca6670e042ULL),
+ make_floatx80_init(0x3ffe, 0x82589994cce1c084ULL) },
+ { make_floatx80_init(0x3ffe, 0x9fffffffffff06f9ULL),
+ make_floatx80_init(0x3fff, 0xc5672a11550655c3ULL),
+ make_floatx80_init(0x3ffe, 0x8ace5422aa0cab86ULL) },
+ { make_floatx80_init(0x3ffe, 0xa7fffffffffff80dULL),
+ make_floatx80_init(0x3fff, 0xc9b9bd866e2f234bULL),
+ make_floatx80_init(0x3ffe, 0x93737b0cdc5e4696ULL) },
+ { make_floatx80_init(0x3ffe, 0xafffffffffff1470ULL),
+ make_floatx80_init(0x3fff, 0xce248c151f83fd69ULL),
+ make_floatx80_init(0x3ffe, 0x9c49182a3f07fad2ULL) },
+ { make_floatx80_init(0x3ffe, 0xb800000000000e0aULL),
+ make_floatx80_init(0x3fff, 0xd2a81d91f12aec5cULL),
+ make_floatx80_init(0x3ffe, 0xa5503b23e255d8b8ULL) },
+ { make_floatx80_init(0x3ffe, 0xc00000000000b7faULL),
+ make_floatx80_init(0x3fff, 0xd744fccad69dd630ULL),
+ make_floatx80_init(0x3ffe, 0xae89f995ad3bac60ULL) },
+ { make_floatx80_init(0x3ffe, 0xc800000000003aa6ULL),
+ make_floatx80_init(0x3fff, 0xdbfbb797daf25a44ULL),
+ make_floatx80_init(0x3ffe, 0xb7f76f2fb5e4b488ULL) },
+ { make_floatx80_init(0x3ffe, 0xd00000000000a6aeULL),
+ make_floatx80_init(0x3fff, 0xe0ccdeec2a954685ULL),
+ make_floatx80_init(0x3ffe, 0xc199bdd8552a8d0aULL) },
+ { make_floatx80_init(0x3ffe, 0xd800000000004165ULL),
+ make_floatx80_init(0x3fff, 0xe5b906e77c837155ULL),
+ make_floatx80_init(0x3ffe, 0xcb720dcef906e2aaULL) },
+ { make_floatx80_init(0x3ffe, 0xe00000000000582cULL),
+ make_floatx80_init(0x3fff, 0xeac0c6e7dd24713aULL),
+ make_floatx80_init(0x3ffe, 0xd5818dcfba48e274ULL) },
+ { make_floatx80_init(0x3ffe, 0xe800000000001a5dULL),
+ make_floatx80_init(0x3fff, 0xefe4b99bdcdb06ebULL),
+ make_floatx80_init(0x3ffe, 0xdfc97337b9b60dd6ULL) },
+ { make_floatx80_init(0x3ffe, 0xefffffffffffc1efULL),
+ make_floatx80_init(0x3fff, 0xf5257d152486a2faULL),
+ make_floatx80_init(0x3ffe, 0xea4afa2a490d45f4ULL) },
+ { make_floatx80_init(0x3ffe, 0xf800000000001069ULL),
+ make_floatx80_init(0x3fff, 0xfa83b2db722a0e5cULL),
+ make_floatx80_init(0x3ffe, 0xf50765b6e4541cb8ULL) },
+ { make_floatx80_init(0x3fff, 0x8000000000000000ULL),
+ make_floatx80_init(0x4000, 0x8000000000000000ULL),
+ make_floatx80_init(0x3fff, 0x8000000000000000ULL) },
};
void helper_f2xm1(CPUX86State *env)
@@ -1275,24 +1275,24 @@
};
static const struct fpatan_data fpatan_table[9] = {
- { floatx80_zero,
- floatx80_zero },
- { make_floatx80(0x3ffb, 0xfeadd4d5617b6e33ULL),
- make_floatx80(0xbfb9, 0xdda19d8305ddc420ULL) },
- { make_floatx80(0x3ffc, 0xfadbafc96406eb15ULL),
- make_floatx80(0x3fbb, 0xdb8f3debef442fccULL) },
- { make_floatx80(0x3ffd, 0xb7b0ca0f26f78474ULL),
- make_floatx80(0xbfbc, 0xeab9bdba460376faULL) },
- { make_floatx80(0x3ffd, 0xed63382b0dda7b45ULL),
- make_floatx80(0x3fbc, 0xdfc88bd978751a06ULL) },
- { make_floatx80(0x3ffe, 0x8f005d5ef7f59f9bULL),
- make_floatx80(0x3fbd, 0xb906bc2ccb886e90ULL) },
- { make_floatx80(0x3ffe, 0xa4bc7d1934f70924ULL),
- make_floatx80(0x3fbb, 0xcd43f9522bed64f8ULL) },
- { make_floatx80(0x3ffe, 0xb8053e2bc2319e74ULL),
- make_floatx80(0xbfbc, 0xd3496ab7bd6eef0cULL) },
- { make_floatx80(0x3ffe, 0xc90fdaa22168c235ULL),
- make_floatx80(0xbfbc, 0xece675d1fc8f8cbcULL) },
+ { floatx80_zero_init,
+ floatx80_zero_init },
+ { make_floatx80_init(0x3ffb, 0xfeadd4d5617b6e33ULL),
+ make_floatx80_init(0xbfb9, 0xdda19d8305ddc420ULL) },
+ { make_floatx80_init(0x3ffc, 0xfadbafc96406eb15ULL),
+ make_floatx80_init(0x3fbb, 0xdb8f3debef442fccULL) },
+ { make_floatx80_init(0x3ffd, 0xb7b0ca0f26f78474ULL),
+ make_floatx80_init(0xbfbc, 0xeab9bdba460376faULL) },
+ { make_floatx80_init(0x3ffd, 0xed63382b0dda7b45ULL),
+ make_floatx80_init(0x3fbc, 0xdfc88bd978751a06ULL) },
+ { make_floatx80_init(0x3ffe, 0x8f005d5ef7f59f9bULL),
+ make_floatx80_init(0x3fbd, 0xb906bc2ccb886e90ULL) },
+ { make_floatx80_init(0x3ffe, 0xa4bc7d1934f70924ULL),
+ make_floatx80_init(0x3fbb, 0xcd43f9522bed64f8ULL) },
+ { make_floatx80_init(0x3ffe, 0xb8053e2bc2319e74ULL),
+ make_floatx80_init(0xbfbc, 0xd3496ab7bd6eef0cULL) },
+ { make_floatx80_init(0x3ffe, 0xc90fdaa22168c235ULL),
+ make_floatx80_init(0xbfbc, 0xece675d1fc8f8cbcULL) },
};
void helper_fpatan(CPUX86State *env)
diff --git a/tests/docker/Makefile.include b/tests/docker/Makefile.include
index a104e9d..9119dff 100644
--- a/tests/docker/Makefile.include
+++ b/tests/docker/Makefile.include
@@ -78,7 +78,7 @@
DEB_ARCH=$(DEB_ARCH) \
DEB_TYPE=$(DEB_TYPE) \
$(if $(DEB_URL),DEB_URL=$(DEB_URL),) \
- $(DOCKER_SCRIPT) build qemu/debian-$* $< \
+ $(DOCKER_SCRIPT) build -t qemu/debian-$* -f $< \
$(if $V,,--quiet) $(if $(NOCACHE),--no-cache) \
$(if $(NOUSER),,--add-current-user) \
$(if $(EXTRA_FILES),--extra-files $(EXTRA_FILES)) \
diff --git a/tests/docker/docker.py b/tests/docker/docker.py
index c9f20d8..356d761 100755
--- a/tests/docker/docker.py
+++ b/tests/docker/docker.py
@@ -24,7 +24,7 @@
import re
import signal
from tarfile import TarFile, TarInfo
-from io import StringIO
+from io import StringIO, BytesIO
from shutil import copy, rmtree
from pwd import getpwuid
from datetime import datetime, timedelta
@@ -541,13 +541,14 @@
# Create a Docker buildfile
df = StringIO()
- df.write("FROM %s\n" % args.tag)
- df.write("ADD . /\n")
- df.seek(0)
+ df.write(u"FROM %s\n" % args.tag)
+ df.write(u"ADD . /\n")
+
+ df_bytes = BytesIO(bytes(df.getvalue(), "UTF-8"))
df_tar = TarInfo(name="Dockerfile")
- df_tar.size = len(df.buf)
- tmp_tar.addfile(df_tar, fileobj=df)
+ df_tar.size = df_bytes.getbuffer().nbytes
+ tmp_tar.addfile(df_tar, fileobj=df_bytes)
tmp_tar.close()
diff --git a/tests/docker/dockerfiles/debian-bootstrap.pre b/tests/docker/dockerfiles/debian-bootstrap.pre
index c164778..35c85f7 100755
--- a/tests/docker/dockerfiles/debian-bootstrap.pre
+++ b/tests/docker/dockerfiles/debian-bootstrap.pre
@@ -80,6 +80,13 @@
fi
#
+# Add optional args
+#
+if [ -n "${DEB_KEYRING}" ]; then
+ DEBOOTSTRAP="${DEBOOTSTRAP} --keyring=${DEB_KEYRING}"
+fi
+
+#
# Finally check to see if any qemu's are installed
#
BINFMT_DIR=/proc/sys/fs/binfmt_misc
diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
index 95f05b0..121959a 100755
--- a/tests/qemu-iotests/197
+++ b/tests/qemu-iotests/197
@@ -112,7 +112,9 @@
echo '=== Partial final cluster ==='
echo
-_make_test_img 1024
+# Force compat=1.1, because writing zeroes on a v2 image without a
+# backing file would just result in an unallocated cluster
+_make_test_img -o compat=1.1 1024
$QEMU_IO -f $IMGFMT -C -c 'read 0 1024' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -f $IMGFMT -c map "$TEST_IMG"
_check_test_img
diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index e0d8049..0657f72 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -595,15 +595,19 @@
fi
export QEMU_PROG="$(type -p "$QEMU_PROG")"
+export QEMU_OPTIONS="-nodefaults -display none -accel qtest"
case "$QEMU_PROG" in
*qemu-system-arm|*qemu-system-aarch64)
- export QEMU_OPTIONS="-nodefaults -display none -machine virt -accel qtest"
+ export QEMU_OPTIONS="$QEMU_OPTIONS -machine virt"
+ ;;
+ *qemu-system-avr)
+ export QEMU_OPTIONS="$QEMU_OPTIONS -machine mega2560"
+ ;;
+ *qemu-system-rx)
+ export QEMU_OPTIONS="$QEMU_OPTIONS -machine gdbsim-r5f562n8"
;;
*qemu-system-tricore)
- export QEMU_OPTIONS="-nodefaults -display none -machine tricore_testboard -accel qtest"
- ;;
- *)
- export QEMU_OPTIONS="-nodefaults -display none -accel qtest"
+ export QEMU_OPTIONS="-$QEMU_OPTIONS -machine tricore_testboard"
;;
esac
diff --git a/tests/vm/basevm.py b/tests/vm/basevm.py
index 7acb48b..3fac20e 100644
--- a/tests/vm/basevm.py
+++ b/tests/vm/basevm.py
@@ -80,6 +80,8 @@
arch = "#arch"
# command to halt the guest, can be overridden by subclasses
poweroff = "poweroff"
+ # Time to wait for shutdown to finish.
+ shutdown_timeout_default = 30
# enable IPv6 networking
ipv6 = True
# This is the timeout on the wait for console bytes.
@@ -87,7 +89,7 @@
# Scale up some timeouts under TCG.
# 4 is arbitrary, but greater than 2,
# since we found we need to wait more than twice as long.
- tcg_ssh_timeout_multiplier = 4
+ tcg_timeout_multiplier = 4
def __init__(self, args, config=None):
self._guest = None
self._genisoimage = args.genisoimage
@@ -141,9 +143,12 @@
if args.jobs and args.jobs > 1:
self._args += ["-smp", "%d" % args.jobs]
if kvm_available(self.arch):
+ self._shutdown_timeout = self.shutdown_timeout_default
self._args += ["-enable-kvm"]
else:
logging.info("KVM not available, not using -enable-kvm")
+ self._shutdown_timeout = \
+ self.shutdown_timeout_default * self.tcg_timeout_multiplier
self._data_args = []
if self._config['qemu_args'] != None:
@@ -423,7 +428,7 @@
def wait_ssh(self, wait_root=False, seconds=300, cmd="exit 0"):
# Allow more time for VM to boot under TCG.
if not kvm_available(self.arch):
- seconds *= self.tcg_ssh_timeout_multiplier
+ seconds *= self.tcg_timeout_multiplier
starttime = datetime.datetime.now()
endtime = starttime + datetime.timedelta(seconds=seconds)
cmd_success = False
@@ -441,14 +446,14 @@
raise Exception("Timeout while waiting for guest ssh")
def shutdown(self):
- self._guest.shutdown()
+ self._guest.shutdown(timeout=self._shutdown_timeout)
def wait(self):
- self._guest.wait()
+ self._guest.wait(timeout=self._shutdown_timeout)
def graceful_shutdown(self):
self.ssh_root(self.poweroff)
- self._guest.wait()
+ self._guest.wait(timeout=self._shutdown_timeout)
def qmp(self, *args, **kwargs):
return self._guest.qmp(*args, **kwargs)
diff --git a/util/oslib-posix.c b/util/oslib-posix.c
index d923674..ad8001a 100644
--- a/util/oslib-posix.c
+++ b/util/oslib-posix.c
@@ -841,3 +841,18 @@
return g_steal_pointer(&hostname);
}
+
+size_t qemu_get_host_physmem(void)
+{
+#ifdef _SC_PHYS_PAGES
+ long pages = sysconf(_SC_PHYS_PAGES);
+ if (pages > 0) {
+ if (pages > SIZE_MAX / qemu_real_host_page_size) {
+ return SIZE_MAX;
+ } else {
+ return pages * qemu_real_host_page_size;
+ }
+ }
+#endif
+ return 0;
+}
diff --git a/util/oslib-win32.c b/util/oslib-win32.c
index 7eedbe5..c654daf 100644
--- a/util/oslib-win32.c
+++ b/util/oslib-win32.c
@@ -828,3 +828,14 @@
return g_utf16_to_utf8(tmp, size, NULL, NULL, NULL);
}
+
+size_t qemu_get_host_physmem(void)
+{
+ MEMORYSTATUSEX statex;
+ statex.dwLength = sizeof(statex);
+
+ if (GlobalMemoryStatusEx(&statex)) {
+ return statex.ullTotalPhys;
+ }
+ return 0;
+}
