* Fix non-deterministic failures of the 'netdev-socket' qtest
* Fix device presence checking in the virtio-ccw qtest
* Support codespell checking in checkpatch.pl
* Fix emulation of LAE s390x instruction
* Work around htags bug when environment is large
* Some other small clean-ups here and there
# -----BEGIN PGP SIGNATURE-----
#
# iQJFBAABCAAvFiEEJ7iIR+7gJQEY8+q5LtnXdP5wLbUFAmWgHlgRHHRodXRoQHJl
# ZGhhdC5jb20ACgkQLtnXdP5wLbXAnBAAjQve/Jmfp9p8eQmswG7cl/a2TuJ59b9X
# SFRja2PprV/Wp4kxxEJX4er9F2+rlMusNL62LBp/QjZi9u4lCvCmuB7sMa0wEkjr
# BPPBrkxkAT+/8vhGpYg2GrxZv/UOLkycp3sjEp4v5yXWQw+OEBnkZZ+AuHddpnEr
# NKMKss71uQmccvuzD5FMDfbJQcSBD/yGPyFfDrv1RKreYRlbkEDVlcVoZpfoMwQY
# Pl167iDdmjVtsT+4wf8vHo5W/AYKDOjlV6AoujCnJVZnGx6BtDLiF/iNJ/VU1Ty5
# cRxySPT64HG+cGrbRqz9IjDvs++WW5EQn1jPY8NO2XFz3sney6Cs/pLKjqJY9S7P
# kfOXOBZG3zOI1kgd/CSR5b4szg4XvtTZaupczKiGOpYC9klf0oQNXGU5jXi3Csop
# Q332oUgiPeNdOx/4tXobFX6RwVCqLRYZbHx9RRYSxWlqJJPAB74/n+RZsmOtsxuJ
# RaiPKDmbVlslkUm78gIa5e6DMwDk2wmlkqa64W7VZxyqfQTRDPiPvfMGePkj6tmZ
# h9vUsELwwORlHpZyL08n0fzs3aeIYwzPwhfr+5iQZIawIp4Zqo8i8Lic/WfIlok9
# rmPIA0mjs1VtrUsroItw4NcY04xcVa7hkhz4EbkZROrfGamdkLuvbk2OKuOeoL0U
# lpgtQL6jA7E=
# =F/j2
# -----END PGP SIGNATURE-----
# gpg: Signature made Thu 11 Jan 2024 16:59:04 GMT
# gpg: using RSA key
27B88847EEE0250118F3EAB92ED9D774FE702DB5
# gpg: issuer "thuth@redhat.com"
# gpg: Good signature from "Thomas Huth <th.huth@gmx.de>" [full]
# gpg: aka "Thomas Huth <thuth@redhat.com>" [full]
# gpg: aka "Thomas Huth <huth@tuxfamily.org>" [full]
# gpg: aka "Thomas Huth <th.huth@posteo.de>" [unknown]
# Primary key fingerprint: 27B8 8847 EEE0 2501 18F3 EAB9 2ED9 D774 FE70 2DB5
* tag 'pull-request-2024-01-11' of https://gitlab.com/thuth/qemu:
.gitlab-ci.d/buildtest.yml: Work around htags bug when environment is large
tests/tcg/s390x: Test LOAD ADDRESS EXTENDED
target/s390x: Fix LAE setting a wrong access register
scripts/checkpatch: Support codespell checking
hw/s390x/ccw: Replace dirname() with g_path_get_dirname()
hw/s390x/ccw: Replace basename() with g_path_get_basename()
target/s390x/kvm/pv: Provide some more useful information if decryption fails
gitlab: fix s390x tag for avocado-system-centos
tests/qtest/virtio-ccw: Fix device presence checking
qtest: ensure netdev-socket tests have non-overlapping names
net: handle QIOTask completion to report useful error message
net: add explicit info about connecting/listening state
Revert "tests/qtest/netdev-socket: Raise connection timeout to 120 seconds"
Revert "osdep: add getloadavg"
Revert "netdev: set timeout depending on loadavg"
qtest: use correct boolean type for failover property
q800: move dp8393x_prom memory region to Q800MachineState
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
variables:
IMAGE: centos8
MAKE_CHECK_ARGS: check-avocado
- AVOCADO_TAGS: arch:ppc64 arch:or1k arch:390x arch:x86_64 arch:rx
+ AVOCADO_TAGS: arch:ppc64 arch:or1k arch:s390x arch:x86_64 arch:rx
arch:sh4 arch:nios2
build-system-opensuse:
- mkdir -p public
# HTML-ised source tree
- make gtags
- - htags -anT --tree-view=filetree -m qemu_init
+ # We unset variables to work around a bug in some htags versions
+ # which causes it to fail when the environment is large
+ - CI_COMMIT_MESSAGE= CI_COMMIT_TAG_MESSAGE= htags
+ -anT --tree-view=filetree -m qemu_init
-t "Welcome to the QEMU sourcecode"
- mv HTML public/src
# Project documentation
int bios_size;
ram_addr_t initrd_base;
int32_t initrd_size;
- MemoryRegion *dp8393x_prom = g_new(MemoryRegion, 1);
uint8_t *prom;
int i, checksum;
MacFbMode *macfb_mode;
sysbus_connect_irq(sysbus, 0,
qdev_get_gpio_in(DEVICE(&m->glue), GLUE_IRQ_IN_SONIC));
- memory_region_init_rom(dp8393x_prom, NULL, "dp8393x-q800.prom",
+ memory_region_init_rom(&m->dp8393x_prom, NULL, "dp8393x-q800.prom",
SONIC_PROM_SIZE, &error_fatal);
memory_region_add_subregion(get_system_memory(), SONIC_PROM_BASE,
- dp8393x_prom);
+ &m->dp8393x_prom);
/* Add MAC address with valid checksum to PROM */
- prom = memory_region_get_ram_ptr(dp8393x_prom);
+ prom = memory_region_get_ram_ptr(&m->dp8393x_prom);
checksum = 0;
for (i = 0; i < 6; i++) {
prom[i] = revbit8(nd_table[0].macaddr.a[i]);
cpu_physical_memory_unmap(addr, len, 1, len);
}
-int s390_ipl_prepare_pv_header(void)
+int s390_ipl_prepare_pv_header(Error **errp)
{
IplParameterBlock *ipib = s390_ipl_get_iplb_pv();
IPLBlockPV *ipib_pv = &ipib->pv;
cpu_physical_memory_read(ipib_pv->pv_header_addr, hdr,
ipib_pv->pv_header_len);
- rc = s390_pv_set_sec_parms((uintptr_t)hdr,
- ipib_pv->pv_header_len);
+ rc = s390_pv_set_sec_parms((uintptr_t)hdr, ipib_pv->pv_header_len, errp);
g_free(hdr);
return rc;
}
int s390_ipl_set_loadparm(uint8_t *loadparm);
void s390_ipl_update_diag308(IplParameterBlock *iplb);
-int s390_ipl_prepare_pv_header(void);
+int s390_ipl_prepare_pv_header(Error **errp);
int s390_ipl_pv_unpack(void);
void s390_ipl_prepare_cpu(S390CPU *cpu);
IplParameterBlock *s390_ipl_get_iplb(void);
Error **errp)
{
unsigned int cssid, ssid, devid;
- char dev_path[PATH_MAX] = {0}, *tmp;
+ char dev_path[PATH_MAX] = {0};
+ g_autofree char *tmp_dir = NULL;
+ g_autofree char *tmp = NULL;
if (!sysfsdev) {
error_setg(errp, "No host device provided");
cdev->mdevid = g_path_get_basename(dev_path);
- tmp = basename(dirname(dev_path));
+ tmp_dir = g_path_get_dirname(dev_path);
+ tmp = g_path_get_basename(tmp_dir);
if (sscanf(tmp, "%2x.%1x.%4x", &cssid, &ssid, &devid) != 3) {
error_setg_errno(errp, errno, "Failed to read %s", tmp);
return;
}
/* Set SE header and unpack */
- rc = s390_ipl_prepare_pv_header();
+ rc = s390_ipl_prepare_pv_header(&local_err);
if (rc) {
goto out_err;
}
return rc;
out_err:
+ if (local_err) {
+ error_report_err(local_err);
+ }
s390_machine_unprotect(ms);
return rc;
}
MOS6522Q800VIA1State via1;
MOS6522Q800VIA2State via2;
dp8393xState dp8393x;
+ MemoryRegion dp8393x_prom;
ESCCState escc;
OrIRQState escc_orgate;
SysBusESPState esp;
}
#endif /* !HAVE_SYSTEM_FUNCTION */
-/**
- * If the load average was unobtainable, -1 is returned
- */
-#ifndef HAVE_GETLOADAVG_FUNCTION
-static inline int getloadavg(double loadavg[], int nelem)
-{
- return -1;
-}
-#endif /* !HAVE_GETLOADAVG_FUNCTION */
-
#ifdef __cplusplus
}
#endif
config_host_data.set('HAVE_OPENPTY', cc.has_function('openpty', dependencies: util))
config_host_data.set('HAVE_STRCHRNUL', cc.has_function('strchrnul'))
config_host_data.set('HAVE_SYSTEM_FUNCTION', cc.has_function('system', prefix: '#include <stdlib.h>'))
-config_host_data.set('HAVE_GETLOADAVG_FUNCTION', cc.has_function('getloadavg', prefix: '#include <stdlib.h>'))
if rbd.found()
config_host_data.set('HAVE_RBD_NAMESPACE_EXISTS',
cc.has_function('rbd_namespace_exists',
s->ioc_write_tag = 0;
}
if (s->listener) {
+ qemu_set_info_str(&s->nc, "listening");
qio_net_listener_set_client_func(s->listener, net_stream_listen,
s, NULL);
}
net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
s->nc.link_down = true;
- qemu_set_info_str(&s->nc, "%s", "");
qapi_event_send_netdev_stream_disconnected(s->nc.name);
net_stream_arm_reconnect(s);
QIOChannelSocket *listen_sioc = QIO_CHANNEL_SOCKET(s->listen_ioc);
SocketAddress *addr;
int ret;
+ Error *err = NULL;
- if (listen_sioc->fd < 0) {
- qemu_set_info_str(&s->nc, "connection error");
+ if (qio_task_propagate_error(task, &err)) {
+ qemu_set_info_str(&s->nc, "error: %s", error_get_pretty(err));
+ error_free(err);
return;
}
s->nc.link_down = true;
s->listener = qio_net_listener_new();
+ qemu_set_info_str(&s->nc, "listening");
net_socket_rs_init(&s->rs, net_stream_rs_finalize, false);
qio_net_listener_set_client_func(s->listener, net_stream_listen, s, NULL);
qio_net_listener_add(s->listener, listen_sioc);
nc = qemu_new_net_client(&net_stream_info, peer, model, name);
s = DO_UPCAST(NetStreamState, nc, nc);
+ qemu_set_info_str(&s->nc, "initializing");
s->listen_ioc = QIO_CHANNEL(listen_sioc);
qio_channel_socket_listen_async(listen_sioc, addr, 0,
SocketAddress *addr;
gchar *uri;
int ret;
+ Error *err = NULL;
- if (sioc->fd < 0) {
- qemu_set_info_str(&s->nc, "connection error");
+ if (qio_task_propagate_error(task, &err)) {
+ qemu_set_info_str(&s->nc, "error: %s", error_get_pretty(err));
+ error_free(err);
goto error;
}
static void net_stream_arm_reconnect(NetStreamState *s)
{
if (s->reconnect && s->timer_tag == 0) {
+ qemu_set_info_str(&s->nc, "connecting");
s->timer_tag = g_timeout_add_seconds(s->reconnect,
net_stream_reconnect, s);
}
nc = qemu_new_net_client(&net_stream_info, peer, model, name);
s = DO_UPCAST(NetStreamState, nc, nc);
+ qemu_set_info_str(&s->nc, "connecting");
s->ioc = QIO_CHANNEL(sioc);
s->nc.link_down = true;
my $root;
my %debug;
my $help = 0;
+my $codespell = 0;
+my $codespellfile = "/usr/share/codespell/dictionary.txt";
+my $user_codespellfile = "";
sub help {
my ($exitcode) = @_;
is all off)
--test-only=WORD report only warnings/errors containing WORD
literally
+ --codespell Use the codespell dictionary for spelling/typos
+ (default: $codespellfile)
+ --codespellfile Use this codespell dictionary
--color[=WHEN] Use colors 'always', 'never', or only when output
is a terminal ('auto'). Default is 'auto'.
-h, --help, --version display this help and exit
}
GetOptions(
- 'q|quiet+' => \$quiet,
- 'tree!' => \$tree,
- 'signoff!' => \$chk_signoff,
- 'patch!' => \$chk_patch,
- 'branch!' => \$chk_branch,
- 'emacs!' => \$emacs,
- 'terse!' => \$terse,
- 'f|file!' => \$file,
- 'strict!' => \$no_warnings,
- 'root=s' => \$root,
- 'summary!' => \$summary,
- 'mailback!' => \$mailback,
- 'summary-file!' => \$summary_file,
-
- 'debug=s' => \%debug,
- 'test-only=s' => \$tst_only,
- 'color=s' => \$color,
- 'no-color' => sub { $color = 'never'; },
- 'h|help' => \$help,
- 'version' => \$help
+ 'q|quiet+' => \$quiet,
+ 'tree!' => \$tree,
+ 'signoff!' => \$chk_signoff,
+ 'patch!' => \$chk_patch,
+ 'branch!' => \$chk_branch,
+ 'emacs!' => \$emacs,
+ 'terse!' => \$terse,
+ 'f|file!' => \$file,
+ 'strict!' => \$no_warnings,
+ 'root=s' => \$root,
+ 'summary!' => \$summary,
+ 'mailback!' => \$mailback,
+ 'summary-file!' => \$summary_file,
+ 'debug=s' => \%debug,
+ 'test-only=s' => \$tst_only,
+ 'codespell!' => \$codespell,
+ 'codespellfile=s' => \$user_codespellfile,
+ 'color=s' => \$color,
+ 'no-color' => sub { $color = 'never'; },
+ 'h|help' => \$help,
+ 'version' => \$help
) or help(1);
+if ($user_codespellfile) {
+ # Use the user provided codespell file unconditionally
+ $codespellfile = $user_codespellfile;
+} elsif (!(-f $codespellfile)) {
+ # If /usr/share/codespell/dictionary.txt is not present, try to find it
+ # under codespell's install directory: <codespell_root>/data/dictionary.txt
+ if (($codespell || $help) && which("python3") ne "") {
+ my $python_codespell_dict = << "EOF";
+
+import os.path as op
+import codespell_lib
+codespell_dir = op.dirname(codespell_lib.__file__)
+codespell_file = op.join(codespell_dir, 'data', 'dictionary.txt')
+print(codespell_file, end='')
+EOF
+
+ my $codespell_dict = `python3 -c "$python_codespell_dict" 2> /dev/null`;
+ $codespellfile = $codespell_dict if (-f $codespell_dict);
+ }
+}
+
help(0) if ($help);
my $exit = 0;
qr{guintptr},
);
+# Load common spelling mistakes and build regular expression list.
+my $misspellings;
+my %spelling_fix;
+
+if ($codespell) {
+ if (open(my $spelling, '<', $codespellfile)) {
+ while (<$spelling>) {
+ my $line = $_;
+
+ $line =~ s/\s*\n?$//g;
+ $line =~ s/^\s*//g;
+
+ next if ($line =~ m/^\s*#/);
+ next if ($line =~ m/^\s*$/);
+ next if ($line =~ m/, disabled/i);
+
+ $line =~ s/,.*$//;
+
+ my ($suspect, $fix) = split(/->/, $line);
+
+ $spelling_fix{$suspect} = $fix;
+ }
+ close($spelling);
+ } else {
+ warn "No codespell typos will be found - file '$codespellfile': $!\n";
+ }
+}
+
+$misspellings = join("|", sort keys %spelling_fix) if keys %spelling_fix;
+
# This can be modified by sub possible. Since it can be empty, be careful
# about regexes that always match, because they can cause infinite loops.
our @modifierList = (
return 1;
}
+sub which {
+ my ($bin) = @_;
+
+ foreach my $path (split(/:/, $ENV{PATH})) {
+ if (-e "$path/$bin") {
+ return "$path/$bin";
+ }
+ }
+
+ return "";
+}
+
sub expand_tabs {
my ($str) = @_;
WARN("8-bit UTF-8 used in possible commit log\n" . $herecurr);
}
+# Check for various typo / spelling mistakes
+ if (defined($misspellings) &&
+ ($in_commit_log || $line =~ /^(?:\+|Subject:)/i)) {
+ while ($rawline =~ /(?:^|[^\w\-'`])($misspellings)(?:[^\w\-'`]|$)/gi) {
+ my $typo = $1;
+ my $blank = copy_spacing($rawline);
+ my $ptr = substr($blank, 0, $-[1]) . "^" x length($typo);
+ my $hereptr = "$hereline$ptr\n";
+ my $typo_fix = $spelling_fix{lc($typo)};
+ $typo_fix = ucfirst($typo_fix) if ($typo =~ /^[A-Z]/);
+ $typo_fix = uc($typo_fix) if ($typo =~ /^[A-Z]+$/);
+ WARN("'$typo' may be misspelled - perhaps '$typo_fix'?\n" . $hereptr);
+ }
+ }
+
# ignore non-hunk lines and lines being removed
next if (!$hunk_line || $line =~ /^-/);
static struct kvm_s390_pv_info_vm info_vm;
static struct kvm_s390_pv_info_dump info_dump;
-static int __s390_pv_cmd(uint32_t cmd, const char *cmdname, void *data)
+static int __s390_pv_cmd(uint32_t cmd, const char *cmdname, void *data,
+ int *pvrc)
{
struct kvm_pv_cmd pv_cmd = {
.cmd = cmd,
"IOCTL rc: %d", cmd, cmdname, pv_cmd.rc, pv_cmd.rrc,
rc);
}
+ if (pvrc) {
+ *pvrc = pv_cmd.rc;
+ }
return rc;
}
* This macro lets us pass the command as a string to the function so
* we can print it on an error.
*/
-#define s390_pv_cmd(cmd, data) __s390_pv_cmd(cmd, #cmd, data)
+#define s390_pv_cmd(cmd, data) __s390_pv_cmd(cmd, #cmd, data, NULL)
+#define s390_pv_cmd_pvrc(cmd, data, pvrc) __s390_pv_cmd(cmd, #cmd, data, pvrc)
#define s390_pv_cmd_exit(cmd, data) \
{ \
int rc; \
\
- rc = __s390_pv_cmd(cmd, #cmd, data);\
+ rc = __s390_pv_cmd(cmd, #cmd, data, NULL); \
if (rc) { \
exit(1); \
} \
return true;
}
-int s390_pv_set_sec_parms(uint64_t origin, uint64_t length)
+int s390_pv_set_sec_parms(uint64_t origin, uint64_t length, Error **errp)
{
+ int ret, pvrc;
struct kvm_s390_pv_sec_parm args = {
.origin = origin,
.length = length,
};
- return s390_pv_cmd(KVM_PV_SET_SEC_PARMS, &args);
+ ret = s390_pv_cmd_pvrc(KVM_PV_SET_SEC_PARMS, &args, &pvrc);
+ if (ret) {
+ error_setg(errp, "Failed to set secure execution parameters");
+ if (pvrc == 0x108) {
+ error_append_hint(errp, "Please check whether the image is "
+ "correctly encrypted for this host\n");
+ }
+ }
+
+ return ret;
}
/*
int s390_pv_vm_enable(void);
void s390_pv_vm_disable(void);
bool s390_pv_vm_try_disable_async(S390CcwMachineState *ms);
-int s390_pv_set_sec_parms(uint64_t origin, uint64_t length);
+int s390_pv_set_sec_parms(uint64_t origin, uint64_t length, Error **errp);
int s390_pv_unpack(uint64_t addr, uint64_t size, uint64_t tweak);
void s390_pv_prep_reset(void);
int s390_pv_verify(void);
static inline int s390_pv_vm_enable(void) { return 0; }
static inline void s390_pv_vm_disable(void) {}
static inline bool s390_pv_vm_try_disable_async(S390CcwMachineState *ms) { return false; }
-static inline int s390_pv_set_sec_parms(uint64_t origin, uint64_t length) { return 0; }
+static inline int s390_pv_set_sec_parms(uint64_t origin, uint64_t length,
+ Error **errp) { return 0; }
static inline int s390_pv_unpack(uint64_t addr, uint64_t size, uint64_t tweak) { return 0; }
static inline void s390_pv_prep_reset(void) {}
static inline int s390_pv_verify(void) { return 0; }
{
int b2 = get_field(s, b2);
TCGv ar1 = tcg_temp_new_i64();
+ int r1 = get_field(s, r1);
o->out = o->in2;
o->in2 = NULL;
break;
}
- tcg_gen_st32_i64(ar1, tcg_env, offsetof(CPUS390XState, aregs[1]));
+ tcg_gen_st32_i64(ar1, tcg_env, offsetof(CPUS390XState, aregs[r1]));
return DISAS_NEXT;
}
#include "qapi/qobject-input-visitor.h"
#include "qapi/qapi-visit-sockets.h"
-#define CONNECTION_TIMEOUT 120
-
-static double connection_timeout(void)
-{
- double load;
- int ret = getloadavg(&load, 1);
-
- /*
- * If we can't get load data, or load is low because we just started
- * running, assume load of 1 (we are alone in this system).
- */
- if (ret < 1 || load < 1.0) {
- load = 1.0;
- }
- /*
- * No one wants to wait more than 10 minutes for this test. Higher load?
- * Too bad.
- */
- if (load > 10.0) {
- fprintf(stderr, "Warning: load %f higher than 10 - test might timeout\n",
- load);
- load = 10.0;
- }
-
- /* if load is high increase timeout as we might not get a chance to run */
- return load * CONNECTION_TIMEOUT;
-}
+#define CONNECTION_TIMEOUT 60
#define EXPECT_STATE(q, e, t) \
do { \
if (g_str_equal(resp, e)) { \
break; \
} \
- } while (g_test_timer_elapsed() < connection_timeout()); \
+ } while (g_test_timer_elapsed() < CONNECTION_TIMEOUT); \
g_assert_cmpstr(resp, ==, e); \
g_free(resp); \
} while (0)
"addr.ipv4=on,addr.ipv6=off,"
"addr.host=127.0.0.1,addr.port=%d", port);
- EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);
+ EXPECT_STATE(qts0, "st0: index=0,type=stream,listening\r\n", 0);
qts1 = qtest_initf("-nodefaults -M none "
"-netdev stream,server=false,id=st0,addr.type=inet,"
"-netdev stream,id=st0,server=true,addr.type=unix,"
"addr.path=%s", path);
- EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);
+ EXPECT_STATE(qts0, "st0: index=0,type=stream,listening\r\n", 0);
qts1 = qtest_initf("-nodefaults -M none "
"-netdev stream,server=false,id=st0,addr.type=unix,"
"addr.ipv4=off,addr.ipv6=on,"
"addr.host=::1,addr.port=%d", port);
- EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);
+ EXPECT_STATE(qts0, "st0: index=0,type=stream,listening\r\n", 0);
qts1 = qtest_initf("-nodefaults -M none "
"-netdev stream,server=false,id=st0,addr.type=inet,"
"addr.type=unix,addr.path=%s,",
path);
- EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);
+ EXPECT_STATE(qts0, "st0: index=0,type=stream,listening\r\n", 0);
qts1 = qtest_initf("-nodefaults -M none "
"-netdev stream,id=st0,server=false,"
"addr.abstract=on",
path);
- EXPECT_STATE(qts0, "st0: index=0,type=stream,\r\n", 0);
+ EXPECT_STATE(qts0, "st0: index=0,type=stream,listening\r\n", 0);
qts1 = qtest_initf("-nodefaults -M none "
"-netdev stream,id=st0,server=false,"
#ifndef _WIN32
qtest_add_func("/netdev/dgram/unix", test_dgram_unix);
#endif
- qtest_add_func("/netdev/stream/unix", test_stream_unix);
+ qtest_add_func("/netdev/stream/unix/oneshot", test_stream_unix);
qtest_add_func("/netdev/stream/unix/reconnect",
test_stream_unix_reconnect);
#ifdef CONFIG_LINUX
if (qtest_has_device("virtio-rng-ccw")) {
qtest_add_func("/virtio/rng/nop", virtio_rng_nop);
}
- if (qtest_has_device("virtio-rng-ccw")) {
+ if (qtest_has_device("virtio-scsi-ccw")) {
qtest_add_func("/virtio/scsi/nop", virtio_scsi_nop);
qtest_add_func("/virtio/scsi/hotplug", virtio_scsi_hotplug);
}
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'rombar': 0,"
"'romfile': '',"
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'off',"
+ "'failover': false,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'off',"
+ "'failover': false,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'off',"
+ "'failover': false,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby1",
"{'bus': 'root2',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs2',"
"'mac': '"MAC_STANDBY1"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby0",
"{'bus': 'root0',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs0',"
"'mac': '"MAC_STANDBY0"'}");
qtest_qmp_device_add(qts, "virtio-net", "standby1",
"{'bus': 'root2',"
- "'failover': 'on',"
+ "'failover': true,"
"'netdev': 'hs2',"
"'mac': '"MAC_STANDBY1"'}");
TESTS+=clc
TESTS+=laalg
TESTS+=add-logical-with-carry
+TESTS+=lae
cdsg: CFLAGS+=-pthread
cdsg: LDFLAGS+=-pthread
--- /dev/null
+/*
+ * Test the LOAD ADDRESS EXTENDED instruction.
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+#include <assert.h>
+#include <stdlib.h>
+
+int main(void)
+{
+ unsigned long long ar = -1, b2 = 100000, r, x2 = 500;
+ /*
+ * Hardcode the register number, since clang does not allow using %rN in
+ * place of %aN.
+ */
+ register unsigned long long r2 __asm__("2");
+ int tmp;
+
+ asm("ear %[tmp],%%a2\n"
+ "lae %%r2,42(%[x2],%[b2])\n"
+ "ear %[ar],%%a2\n"
+ "sar %%a2,%[tmp]"
+ : [tmp] "=&r" (tmp), "=&r" (r2), [ar] "+r" (ar)
+ : [b2] "r" (b2), [x2] "r" (x2)
+ : "memory");
+ r = r2;
+ assert(ar == 0xffffffff00000000ULL);
+ assert(r == 100542);
+
+ return EXIT_SUCCESS;
+}
projects / mirror_qemu.git / commitdiff