- ..\msys64\usr\bin\bash -lc '../configure --target-list=ppc64-softmmu
--disable-opengl'
- ..\msys64\usr\bin\bash -lc 'make'
- - ..\msys64\usr\bin\bash -lc 'make check || { cat meson-logs/testlog.txt; exit 1; } ;'
+ - ..\msys64\usr\bin\bash -lc 'make check MTESTARGS=\"--no-suite qtest\" ||
+ { cat meson-logs/testlog.txt; exit 1; }'
R: Jiaxun Yang <jiaxun.yang@flygoat.com>
S: Odd Fixes
K: ^Subject:.*(?i)mips
+F: docs/system/target-mips.rst
+F: configs/targets/mips*
Guest CPU cores (TCG)
---------------------
ret = -errno;
goto out;
}
- do {
- ret = read(sysfd, buf, sizeof(buf) - 1);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(read(sysfd, buf, sizeof(buf) - 1));
if (ret < 0) {
ret = -errno;
goto out;
RawPosixAIOData *aiocb = opaque;
int ret;
- do {
- ret = ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(
+ ioctl(aiocb->aio_fildes, aiocb->ioctl.cmd, aiocb->ioctl.buf)
+ );
if (ret == -1) {
return -errno;
}
{
ssize_t len;
- do {
- if (aiocb->aio_type & QEMU_AIO_WRITE)
- len = qemu_pwritev(aiocb->aio_fildes,
- aiocb->io.iov,
- aiocb->io.niov,
- aiocb->aio_offset);
- else
- len = qemu_preadv(aiocb->aio_fildes,
- aiocb->io.iov,
- aiocb->io.niov,
- aiocb->aio_offset);
- } while (len == -1 && errno == EINTR);
+ len = RETRY_ON_EINTR(
+ (aiocb->aio_type & QEMU_AIO_WRITE) ?
+ qemu_pwritev(aiocb->aio_fildes,
+ aiocb->io.iov,
+ aiocb->io.niov,
+ aiocb->aio_offset) :
+ qemu_preadv(aiocb->aio_fildes,
+ aiocb->io.iov,
+ aiocb->io.niov,
+ aiocb->aio_offset)
+ );
if (len == -1) {
return -errno;
buf = qemu_memalign(max_align, write_size);
memset(buf, 0, write_size);
- do {
- n = pwrite(fd, buf, write_size, 0);
- } while (n == -1 && errno == EINTR);
+ n = RETRY_ON_EINTR(pwrite(fd, buf, write_size, 0));
ret = (n == -1) ? -errno : 0;
{
int fd = -1;
- TFR(fd = qemu_open_old(src, flags, 0666));
+ fd = RETRY_ON_EINTR(qemu_open_old(src, flags, 0666));
if (fd == -1) {
error_setg_file_open(errp, errno, src);
}
filename_in = g_strdup_printf("%s.in", filename);
filename_out = g_strdup_printf("%s.out", filename);
- TFR(fd_in = qemu_open_old(filename_in, O_RDWR | O_BINARY));
- TFR(fd_out = qemu_open_old(filename_out, O_RDWR | O_BINARY));
+ fd_in = RETRY_ON_EINTR(qemu_open_old(filename_in, O_RDWR | O_BINARY));
+ fd_out = RETRY_ON_EINTR(qemu_open_old(filename_out, O_RDWR | O_BINARY));
g_free(filename_in);
g_free(filename_out);
if (fd_in < 0 || fd_out < 0) {
if (fd_out >= 0) {
close(fd_out);
}
- TFR(fd_in = fd_out = qemu_open_old(filename, O_RDWR | O_BINARY));
+ fd_in = fd_out = RETRY_ON_EINTR(
+ qemu_open_old(filename, O_RDWR | O_BINARY)
+ );
if (fd_in < 0) {
error_setg_file_open(errp, errno, filename);
return;
pfd.fd = fioc->fd;
pfd.events = G_IO_OUT;
pfd.revents = 0;
- do {
- rc = g_poll(&pfd, 1, 0);
- } while (rc == -1 && errno == EINTR);
+ rc = RETRY_ON_EINTR(g_poll(&pfd, 1, 0));
assert(rc >= 0);
if (pfd.revents & G_IO_HUP) {
Using ``-drive if=none`` to configure the OTP device of the sifive_u
RISC-V machine is deprecated. Use ``-drive if=pflash`` instead.
+``-no-hpet`` (since 8.0)
+''''''''''''''''''''''''
+
+The HPET setting has been turned into a machine property.
+Use ``-machine hpet=off`` instead.
+
QEMU Machine Protocol (QMP) commands
------------------------------------
vhost-user-gpu
vhost-vdpa
virtio-balloon-stats
+ vnc-ledstate-pseudo-encoding
if (fd == -1) {
return -1;
}
- do {
- tsize = read(fd, (void *)buf, bufsz);
- } while (tsize == -1 && errno == EINTR);
+ tsize = RETRY_ON_EINTR(read(fd, (void *)buf, bufsz));
close_preserve_errno(fd);
} else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) ||
(fs_ctx->export_flags & V9FS_SM_NONE)) {
}
/* Write the oldpath (target) to the file. */
oldpath_size = strlen(oldpath);
- do {
- write_size = write(fd, (void *)oldpath, oldpath_size);
- } while (write_size == -1 && errno == EINTR);
+ write_size = RETRY_ON_EINTR(write(fd, (void *)oldpath, oldpath_size));
close_preserve_errno(fd);
if (write_size != oldpath_size) {
#include "qemu/osdep.h"
#include "exec/memop.h"
-#include "exec/memory-internal.h"
+#include "exec/memory.h"
#include "qemu/error-report.h"
#include "sysemu/hw_accel.h"
#include "hw/pci/pci_device.h"
extern const MemoryRegionOps unassigned_mem_ops;
-bool memory_region_access_valid(MemoryRegion *mr, hwaddr addr,
- unsigned size, bool is_write,
- MemTxAttrs attrs);
-
void flatview_add_to_dispatch(FlatView *fv, MemoryRegionSection *section);
AddressSpaceDispatch *address_space_dispatch_new(FlatView *fv);
void address_space_dispatch_compact(AddressSpaceDispatch *d);
void mtree_info(bool flatview, bool dispatch_tree, bool owner, bool disabled);
+bool memory_region_access_valid(MemoryRegion *mr, hwaddr addr,
+ unsigned size, bool is_write,
+ MemTxAttrs attrs);
+
/**
* memory_region_dispatch_read: perform a read directly to the specified
* MemoryRegion.
#define ESHUTDOWN 4099
#endif
-#define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
+#define RETRY_ON_EINTR(expr) \
+ (__extension__ \
+ ({ typeof(expr) __result; \
+ do { \
+ __result = (expr); \
+ } while (__result == -1 && errno == EINTR); \
+ __result; }))
/* time_t may be either 32 or 64 bits depending on the host OS, and
* can be either signed or unsigned, so we can't just hardcode a
message.msg_control = NULL;
message.msg_controllen = 0;
message.msg_flags = 0;
- do {
- ret = sendmsg(s->fd, &message, 0);
- } while ((ret == -1) && (errno == EINTR));
+ ret = RETRY_ON_EINTR(sendmsg(s->fd, &message, 0));
if (ret > 0) {
ret -= s->offset;
} else if (ret == 0) {
message.msg_control = NULL;
message.msg_controllen = 0;
message.msg_flags = 0;
- do {
- ret = sendmsg(s->fd, &message, 0);
- } while ((ret == -1) && (errno == EINTR));
+ ret = RETRY_ON_EINTR(sendmsg(s->fd, &message, 0));
if (ret > 0) {
ret -= s->offset;
} else if (ret == 0) {
msgvec = s->msgvec + s->queue_head;
if (target_count > 0) {
- do {
- count = recvmmsg(
- s->fd,
- msgvec,
- target_count, MSG_DONTWAIT, NULL);
- } while ((count == -1) && (errno == EINTR));
+ count = RETRY_ON_EINTR(
+ recvmmsg(s->fd, msgvec, target_count, MSG_DONTWAIT, NULL)
+ );
if (count < 0) {
/* Recv error - we still need to flush packets here,
* (re)set queue head to current position
NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
ssize_t ret;
- do {
- if (s->dgram_dst.sin_family != AF_UNIX) {
- ret = sendto(s->fd, buf, size, 0,
- (struct sockaddr *)&s->dgram_dst,
- sizeof(s->dgram_dst));
- } else {
- ret = send(s->fd, buf, size, 0);
- }
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(
+ s->dgram_dst.sin_family != AF_UNIX ?
+ sendto(s->fd, buf, size, 0,
+ (struct sockaddr *)&s->dgram_dst,
+ sizeof(s->dgram_dst)) :
+ send(s->fd, buf, size, 0)
+ );
if (ret == -1 && errno == EAGAIN) {
net_socket_write_poll(s, true);
} else {
snprintf(dname, sizeof dname, "/dev/tap%d", i);
}
- TFR(fd = open(dname, O_RDWR));
+ fd = RETRY_ON_EINTR(open(dname, O_RDWR));
if (fd >= 0) {
break;
}
int fd, s, ret;
struct ifreq ifr;
- TFR(fd = open(PATH_NET_TAP, O_RDWR));
+ fd = RETRY_ON_EINTR(open(PATH_NET_TAP, O_RDWR));
if (fd < 0) {
error_setg_errno(errp, errno, "could not open %s", PATH_NET_TAP);
return -1;
if (ifname[0] != '\0') {
char dname[100];
snprintf(dname, sizeof dname, "/dev/%s", ifname);
- TFR(fd = open(dname, O_RDWR));
+ fd = RETRY_ON_EINTR(open(dname, O_RDWR));
if (fd < 0 && errno != ENOENT) {
error_setg_errno(errp, errno, "could not open %s", dname);
return -1;
int len = sizeof(struct virtio_net_hdr);
unsigned int features;
- TFR(fd = open(PATH_NET_TUN, O_RDWR));
+ fd = RETRY_ON_EINTR(open(PATH_NET_TUN, O_RDWR));
if (fd < 0) {
error_setg_errno(errp, errno, "could not open %s", PATH_NET_TUN);
return -1;
if( ip_fd )
close(ip_fd);
- TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
+ ip_fd = RETRY_ON_EINTR(open("/dev/udp", O_RDWR, 0));
if (ip_fd < 0) {
error_setg(errp, "Can't open /dev/ip (actually /dev/udp)");
return -1;
}
- TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
+ tap_fd = RETRY_ON_EINTR(open("/dev/tap", O_RDWR, 0));
if (tap_fd < 0) {
error_setg(errp, "Can't open /dev/tap");
return -1;
if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
error_report("Can't assign new interface");
- TFR(if_fd = open("/dev/tap", O_RDWR, 0));
+ if_fd = RETRY_ON_EINTR(open("/dev/tap", O_RDWR, 0));
if (if_fd < 0) {
error_setg(errp, "Can't open /dev/tap (2)");
return -1;
if (ioctl (ip_fd, I_PUSH, "arp") < 0)
error_report("Can't push ARP module (3)");
/* Open arp_fd */
- TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
+ arp_fd = RETRY_ON_EINTR(open("/dev/tap", O_RDWR, 0));
if (arp_fd < 0)
error_report("Can't open %s", "/dev/tap");
{
ssize_t len;
- do {
- len = writev(s->fd, iov, iovcnt);
- } while (len == -1 && errno == EINTR);
+ len = RETRY_ON_EINTR(writev(s->fd, iov, iovcnt));
if (len == -1 && errno == EAGAIN) {
tap_write_poll(s, true);
close(sv[1]);
- do {
- fd = recv_fd(sv[0]);
- } while (fd == -1 && errno == EINTR);
+ fd = RETRY_ON_EINTR(recv_fd(sv[0]));
saved_errno = errno;
close(sv[0]);
vnet_hdr_required = 0;
}
- TFR(fd = tap_open(ifname, ifname_sz, vnet_hdr, vnet_hdr_required,
+ fd = RETRY_ON_EINTR(tap_open(ifname, ifname_sz, vnet_hdr, vnet_hdr_required,
mq_required, errp));
if (fd < 0) {
return -1;
error_report("not able to chdir to /: %s", strerror(errno));
exit(1);
}
- TFR(fd = qemu_open_old("/dev/null", O_RDWR));
+ fd = RETRY_ON_EINTR(qemu_open_old("/dev/null", O_RDWR));
if (fd == -1) {
exit(1);
}
"-no-hpet disable HPET\n", QEMU_ARCH_I386)
SRST
``-no-hpet``
- Disable HPET support.
+ Disable HPET support. Deprecated, use '-machine hpet=off' instead.
ERST
DEF("acpitable", HAS_ARG, QEMU_OPTION_acpitable,
*status = 0;
- do {
- rpid = waitpid(pid, status, 0);
- } while (rpid == -1 && errno == EINTR);
+ rpid = RETRY_ON_EINTR(waitpid(pid, status, 0));
if (rpid == -1) {
error_setg_errno(errp, errno, "failed to wait for child (pid: %d)",
complete(cs, -1, EFAULT);
return;
}
- do {
- ret = read(gf->hostfd, ptr, len);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(read(gf->hostfd, ptr, len));
if (ret == -1) {
complete(cs, -1, errno);
unlock_user(ptr, buf, 0);
qdict_put_str(machine_opts_dict, "acpi", "off");
break;
case QEMU_OPTION_no_hpet:
+ warn_report("-no-hpet is deprecated, use '-machine hpet=off' instead");
qdict_put_str(machine_opts_dict, "hpet", "off");
break;
case QEMU_OPTION_no_reboot:
#include "s390x-internal.h"
#include "kvm/kvm_s390x.h"
#include "sysemu/kvm.h"
-#include "sysemu/reset.h"
#include "qemu/module.h"
#include "trace.h"
#include "qapi/qapi-types-machine.h"
#include "fpu/softfloat-helpers.h"
#include "disas/capstone.h"
#include "sysemu/tcg.h"
+#ifndef CONFIG_USER_ONLY
+#include "sysemu/reset.h"
+#endif
#define CR0_RESET 0xE0UL
#define CR14_RESET 0xC2000000UL;
#include "qemu/osdep.h"
#include "qemu/module.h"
#include "cpu_features.h"
+#ifndef CONFIG_USER_ONLY
#include "hw/s390x/pv.h"
+#endif
#define DEF_FEAT(_FEAT, _NAME, _TYPE, _BIT, _DESC) \
[S390_FEAT_##_FEAT] = { \
feat = find_next_bit(features, S390_FEAT_MAX, feat + 1);
}
+#ifndef CONFIG_USER_ONLY
if (!s390_is_pv()) {
return;
}
default:
return;
}
+#endif
}
void s390_add_from_feat_block(S390FeatBitmap features, S390FeatType type,
#include "qemu/qemu-print.h"
#ifndef CONFIG_USER_ONLY
#include "sysemu/sysemu.h"
-#endif
#include "hw/s390x/pv.h"
+#endif
#define CPUDEF_INIT(_type, _gen, _ec_ga, _mha_pow, _hmfai, _name, _desc) \
{ \
return 0;
}
+#ifndef CONFIG_USER_ONLY
if (s390_is_pv()) {
switch (feat) {
case S390_FEAT_DIAG_318:
break;
}
}
+#endif
return test_bit(feat, cpu->model->features);
}
#include "qemu/osdep.h"
#include "qemu/log.h"
#include "cpu.h"
-#include "s390x-internal.h"
#include "exec/helper-proto.h"
-#include "qemu/timer.h"
#include "exec/exec-all.h"
#include "exec/cpu_ldst.h"
-#include "hw/s390x/ioinst.h"
-#include "exec/address-spaces.h"
+#include "s390x-internal.h"
#include "tcg_s390x.h"
#ifndef CONFIG_USER_ONLY
+#include "qemu/timer.h"
+#include "exec/address-spaces.h"
+#include "hw/s390x/ioinst.h"
#include "hw/s390x/s390_flic.h"
#include "hw/boards.h"
#endif
#include "qemu/main-loop.h"
#include "cpu.h"
#include "s390x-internal.h"
-#include "exec/memory.h"
#include "qemu/host-utils.h"
#include "exec/helper-proto.h"
#include "qemu/timer.h"
'x-iops-total=10000,x-bps-total=104857600')
self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
self.vm.add_device('virtio-blk,iothread=iothr0,drive=throttled-node')
+ if iotests.qemu_default_machine == 's390-ccw-virtio':
+ self.vm.add_args('-no-shutdown')
self.vm.launch()
def tearDown(self) -> None:
typedef struct {
bool tcg_only;
const char *machine;
+ const char *machine_param;
const char *variant;
const char *uefi_fl1;
const char *uefi_fl2;
* when arm/virt boad starts to support it.
*/
if (data->cd) {
- args = g_strdup_printf("-machine %s %s -accel tcg "
+ args = g_strdup_printf("-machine %s%s %s -accel tcg "
"-nodefaults -nographic "
"-drive if=pflash,format=raw,file=%s,readonly=on "
"-drive if=pflash,format=raw,file=%s,snapshot=on -cdrom %s %s",
- data->machine, data->tcg_only ? "" : "-accel kvm",
+ data->machine, data->machine_param ?: "",
+ data->tcg_only ? "" : "-accel kvm",
data->uefi_fl1, data->uefi_fl2, data->cd, params ? params : "");
} else {
- args = g_strdup_printf("-machine %s %s -accel tcg "
+ args = g_strdup_printf("-machine %s%s %s -accel tcg "
"-nodefaults -nographic "
"-drive if=pflash,format=raw,file=%s,readonly=on "
"-drive if=pflash,format=raw,file=%s,snapshot=on %s",
- data->machine, data->tcg_only ? "" : "-accel kvm",
+ data->machine, data->machine_param ?: "",
+ data->tcg_only ? "" : "-accel kvm",
data->uefi_fl1, data->uefi_fl2, params ? params : "");
}
} else {
- args = g_strdup_printf("-machine %s %s -accel tcg "
+ args = g_strdup_printf("-machine %s%s %s -accel tcg "
"-net none %s "
"-drive id=hd0,if=none,file=%s,format=raw "
"-device %s,drive=hd0 ",
- data->machine, data->tcg_only ? "" : "-accel kvm",
+ data->machine, data->machine_param ?: "",
+ data->tcg_only ? "" : "-accel kvm",
params ? params : "", disk,
data->blkdev ?: "ide-hd");
}
memset(&data, 0, sizeof(data));
data.machine = MACHINE_PC;
+ data.machine_param = ",hpet=off";
data.variant = ".nohpet";
- test_acpi_one("-no-hpet", &data);
+ test_acpi_one(NULL, &data);
free_test_data(&data);
}
memset(&data, 0, sizeof(data));
data.machine = MACHINE_Q35;
+ data.machine_param = ",hpet=off";
data.variant = ".nohpet";
- test_acpi_one("-no-hpet", &data);
+ test_acpi_one(NULL, &data);
free_test_data(&data);
}
#ifndef _WIN32
pid_t pid;
- TFR(pid = waitpid(s->qemu_pid, &s->wstatus, 0));
+ pid = RETRY_ON_EINTR(waitpid(s->qemu_pid, &s->wstatus, 0));
assert(pid == s->qemu_pid);
#else
DWORD ret;
addr.sun_family = AF_UNIX;
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
- do {
- ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(bind(sock, (struct sockaddr *)&addr, sizeof(addr)));
g_assert_cmpint(ret, !=, -1);
ret = listen(sock, 1);
g_assert_cmpint(ret, !=, -1);
QTestState *qts;
const char *cfgdata =
"[spice]\n"
- "disable-ticketing = \"on\"\n"
- "unix = \"on\"\n";
+#ifndef WIN32
+ "unix = \"on\"\n"
+#endif
+ "disable-ticketing = \"on\"\n";
qts = qtest_init_with_config(cfgdata);
/* Test valid command */
.msg_iovlen = num,
.msg_flags = MSG_DONTWAIT,
};
- do {
- ret = recvmsg(vubr->backend_udp_sock, &msg, 0);
- } while (ret == -1 && (errno == EINTR));
+ ret = RETRY_ON_EINTR(recvmsg(vubr->backend_udp_sock, &msg, 0));
if (i == 0) {
iov_restore_front(elem->in_sg, sg, hdrlen);
# more cores. but only up to a reasonable limit. User
# can always override these limits with --jobs.
return min(multiprocessing.cpu_count() // 2, 8)
- else:
- return 1
+ return 1
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
ssize_t len;
while (1) {
- do {
- len = read(fd, &info, sizeof(info));
- } while (len == -1 && errno == EINTR);
+ len = RETRY_ON_EINTR(read(fd, &info, sizeof(info)));
if (len == -1 && errno == EAGAIN) {
break;
.l_type = fl_type,
};
qemu_probe_lock_ops();
- do {
- ret = fcntl(fd, fcntl_op_setlk, &fl);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(fcntl(fd, fcntl_op_setlk, &fl));
return ret == -1 ? -errno : 0;
}
s->config_region_info.offset,
s->config_region_info.size);
assert(QEMU_IS_ALIGNED(s->config_region_info.offset + ofs, size));
- do {
- ret = pread(s->device, buf, size, s->config_region_info.offset + ofs);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(
+ pread(s->device, buf, size, s->config_region_info.offset + ofs)
+ );
return ret == size ? 0 : -errno;
}
s->config_region_info.offset,
s->config_region_info.size);
assert(QEMU_IS_ALIGNED(s->config_region_info.offset + ofs, size));
- do {
- ret = pwrite(s->device, buf, size, s->config_region_info.offset + ofs);
- } while (ret == -1 && errno == EINTR);
+ ret = RETRY_ON_EINTR(
+ pwrite(s->device, buf, size, s->config_region_info.offset + ofs)
+ );
return ret == size ? 0 : -errno;
}
projects / thirdparty / qemu.git / commitdiff
