dfaggioli/qemu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'remotes/stsquad/tags/pull-fixes-for-rc2-270720-1' into staging

Browse Source 
Various fixes for rc2:

  - get shippable working again
  - semihosting bug fixes
  - tweak tb-size handling for low memory machines
  - i386 compound literal float fix
  - linux-user MAP_FIXED->MAP_NOREPLACE on fallback
  - docker binfmt_misc fixes
  - linux-user nanosleep fix
  - tests/vm drain console fixes

# gpg: Signature made Mon 27 Jul 2020 09:45:31 BST
# gpg:                using RSA key 6685AE99E75167BCAFC8DF35FBD0DB095A9E2A44
# gpg: Good signature from "Alex Bennée (Master Work Key) <alex.bennee@linaro.org>" [full]
# Primary key fingerprint: 6685 AE99 E751 67BC AFC8  DF35 FBD0 DB09 5A9E 2A44

* remotes/stsquad/tags/pull-fixes-for-rc2-270720-1:
  tests/vm: add shutdown timeout in basevm.py
  python/qemu: Change ConsoleSocket to optionally drain socket.
  python/qemu: Cleanup changes to ConsoleSocket
  linux-user, ppc: fix clock_nanosleep() for linux-user-ppc
  linux-user: fix clock_nanosleep()
  tests/docker: add support for DEB_KEYRING
  tests/docker: fix binfmt_misc image building
  tests/docker: fix update command due to python3 str/bytes distinction
  linux-user: don't use MAP_FIXED in pgd_find_hole_fallback
  target/i386: floatx80: avoid compound literals in static initializers
  accel/tcg: better handle memory constrained systems
  util/oslib-win32: add qemu_get_host_physmem implementation
  util: add qemu_get_host_physmem utility function
  semihosting: don't send the trailing '\0'
  semihosting: defer connect_chardevs a little more to use serialx
  shippable: add one more qemu to registry url

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
2020-07-27 15:55:56 +01:00
parent 4215d34132 4a70232b1d
commit cb320a07e6
18 changed files with 390 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.shippable.yml
View File

@@ -27,7 +27,7 @@ env:
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"

7
accel/tcg/translate-all.c
View File

@@ -976,7 +976,12 @@ static inline size_t size_code_gen_buffer(size_t tb_size)
{
/* 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;

4
hw/semihosting/console.c
View File

@@ -52,7 +52,9 @@ static GString *copy_user_string(CPUArchState *env, target_ulong addr)
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,

1
include/fpu/softfloat.h
View File

@@ -822,6 +822,7 @@ static inline bool floatx80_invalid_encoding(floatx80 a)
}
#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)

15
include/qemu/osdep.h
View File

@@ -173,6 +173,9 @@ extern int daemon(int, int);
#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 @@ static inline void qemu_reset_optind(void)
*/
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

10
linux-user/elfload.c
View File

@@ -2134,12 +2134,15 @@ static uintptr_t pgd_find_hole_fallback(uintptr_t guest_size, uintptr_t brk,
/* 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 @@ static void pgb_reserved_va(const char *image_name, abi_ulong guest_loaddr,
/* 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);

15
linux-user/syscall.c
View File

@@ -11831,16 +11831,15 @@ static abi_long do_syscall1(void *cpu_env, int num, abi_long arg1,
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

137
python/qemu/console_socket.py
View File

@@ -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)

14
python/qemu/machine.py
View File

@@ -23,11 +23,10 @@ import os
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 @@ class QEMUMachine:
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

2
python/qemu/pylintrc
View File

@@ -33,7 +33,7 @@ good-names=i,
Run,
_,
fd,
c,
[VARIABLES]
[STRING]

5
softmmu/vl.c
View File

@@ -4127,8 +4127,6 @@ void qemu_init(int argc, char **argv, char **envp)
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 @@ void qemu_init(int argc, char **argv, char **envp)
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);

426
target/i386/fpu_helper.c
View File

@@ -868,201 +868,201 @@ struct f2xm1_data {
};
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 @@ struct fpatan_data {
};
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)

2
tests/docker/Makefile.include
View File

@@ -78,7 +78,7 @@ docker-binfmt-image-debian-%: $(DOCKER_FILES_DIR)/debian-bootstrap.docker
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)) \

13
tests/docker/docker.py
View File

@@ -24,7 +24,7 @@ import tempfile
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 @@ class UpdateCommand(SubCommand):
# 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()

7
tests/docker/dockerfiles/debian-bootstrap.pre
View File

@@ -79,6 +79,13 @@ else
fi
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
#

15
tests/vm/basevm.py
View File

@@ -80,6 +80,8 @@ class BaseVM(object):
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 @@ class BaseVM(object):
# 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 @@ class BaseVM(object):
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 @@ class BaseVM(object):
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 @@ class BaseVM(object):
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)

15
util/oslib-posix.c
View File

@@ -841,3 +841,18 @@ char *qemu_get_host_name(Error **errp)
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;
}

11
util/oslib-win32.c
View File

@@ -828,3 +828,14 @@ char *qemu_get_host_name(Error **errp)
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;
}