haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

virtio,pc features, fixes

Browse source 
New features:
     guest RAM buffer overrun mitigation
     RAM physical address gaps for memory hotplug
     (except refactoring which got some review comments)
 
 Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v1
 
 iQEcBAABAgAGBQJWDo8IAAoJECgfDbjSjVRpCwgH/jmj2sYXmP2ywGxsHOS7JKEF
 DyF9crBbrNnkB0+qpON0vmCeoFx5AX6CeyWC0w2bFy4z2yN9lb7jKenkp/guHWne
 eX4x5RVpvW9Ed1l9v4vGuI+5IB3gvZEXQB4hiAMz5fXMCVs0OZ4dyRODHqyXKMvy
 lBCdb0YVvZOPYxRYhnAllOt0uBLLY8pl5i6QGekFkfQMCrsLagySqLPkRNTR0l8O
 2PNd3oBPJi5Qb2jWyJNS45mPMDU6lEIiZSbzn7zAUVduu15hqS9VYZPlZzrNazSu
 7hx6Zegq0G1MMpiVhwlpi5Ov1hqAA+zAIl4QcTN31ueHYdxD/x310nAqtm7Eov4=
 =iFA1
 -----END PGP SIGNATURE-----

Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging

virtio,pc features, fixes

New features:
    guest RAM buffer overrun mitigation
    RAM physical address gaps for memory hotplug
    (except refactoring which got some review comments)

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>

# gpg: Signature made Fri 02 Oct 2015 15:04:56 BST using RSA key ID D28D5469
# gpg: Good signature from "Michael S. Tsirkin <mst@kernel.org>"
# gpg:                 aka "Michael S. Tsirkin <mst@redhat.com>"

* remotes/mst/tags/for_upstream:
  vhost-user-test: fix predictable filename on tmpfs
  vhost-user-test: use tmpfs by default
  pc: memhp: force gaps between DIMM's GPA
  memhp: extend address auto assignment to support gaps
  vhost-user: unit test for new messages
  vhost-user-test: do not reinvent glib-compat.h
  virtio: Notice when the system doesn't support MSIx at all
  pc: Add a comment explaining why pc_compat_2_4() doesn't exist
  exec: allocate PROT_NONE pages on top of RAM
  oslib: allocate PROT_NONE pages on top of RAM
  oslib: rework anonimous RAM allocation
  virtio-net: correctly drop truncated packets
  virtio: introduce virtqueue_discard()
  virtio: introduce virtqueue_unmap_sg()

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell 2015-10-02 16:59:21 +01:00
parent 945507d6bc 6fdac09370
commit c0b520dfb8
14 changed files with 179 additions and 147 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

42
exec.c
View file

@ -84,6 +84,9 @@ static MemoryRegion io_mem_unassigned;
*/
#define RAM_RESIZEABLE (1 << 2)
/* An extra page is mapped on top of this RAM.
*/
#define RAM_EXTRA (1 << 3)
#endif
struct CPUTailQ cpus = QTAILQ_HEAD_INITIALIZER(cpus);
@ -1185,10 +1188,13 @@ static void *file_ram_alloc(RAMBlock *block,
char *filename;
char *sanitized_name;
char *c;
void *ptr;
void *area = NULL;
int fd;
uint64_t hpagesize;
uint64_t total;
Error *local_err = NULL;
size_t offset;
hpagesize = gethugepagesize(path, &local_err);
if (local_err) {
@ -1232,6 +1238,7 @@ static void *file_ram_alloc(RAMBlock *block,
g_free(filename);
memory = ROUND_UP(memory, hpagesize);
total = memory + hpagesize;
/*
* ftruncate is not supported by hugetlbfs in older
@ -1243,16 +1250,40 @@ static void *file_ram_alloc(RAMBlock *block,
perror("ftruncate");
}
area = mmap(0, memory, PROT_READ | PROT_WRITE,
(block->flags & RAM_SHARED ? MAP_SHARED : MAP_PRIVATE),
ptr = mmap(0, total, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS,
-1, 0);
if (ptr == MAP_FAILED) {
error_setg_errno(errp, errno,
"unable to allocate memory range for hugepages");
close(fd);
goto error;
}
offset = QEMU_ALIGN_UP((uintptr_t)ptr, hpagesize) - (uintptr_t)ptr;
area = mmap(ptr + offset, memory, PROT_READ | PROT_WRITE,
(block->flags & RAM_SHARED ? MAP_SHARED : MAP_PRIVATE) |
MAP_FIXED,
fd, 0);
if (area == MAP_FAILED) {
error_setg_errno(errp, errno,
"unable to map backing store for hugepages");
munmap(ptr, total);
close(fd);
goto error;
}
if (offset > 0) {
munmap(ptr, offset);
}
ptr += offset;
total -= offset;
if (total > memory + getpagesize()) {
munmap(ptr + memory + getpagesize(),
total - memory - getpagesize());
}
if (mem_prealloc) {
os_mem_prealloc(fd, area, memory);
}
@ -1570,6 +1601,7 @@ ram_addr_t qemu_ram_alloc_from_file(ram_addr_t size, MemoryRegion *mr,
new_block->used_length = size;
new_block->max_length = size;
new_block->flags = share ? RAM_SHARED : 0;
new_block->flags |= RAM_EXTRA;
new_block->host = file_ram_alloc(new_block, size,
mem_path, errp);
if (!new_block->host) {
@ -1671,7 +1703,11 @@ static void reclaim_ramblock(RAMBlock *block)
xen_invalidate_map_cache_entry(block->host);
#ifndef _WIN32
} else if (block->fd >= 0) {
munmap(block->host, block->max_length);
if (block->flags & RAM_EXTRA) {
munmap(block->host, block->max_length + getpagesize());
} else {
munmap(block->host, block->max_length);
}
close(block->fd);
#endif
} else {

5
hw/i386/pc.c
View file

@ -1629,6 +1629,7 @@ static void pc_dimm_plug(HotplugHandler *hotplug_dev,
HotplugHandlerClass *hhc;
Error *local_err = NULL;
PCMachineState *pcms = PC_MACHINE(hotplug_dev);
PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
PCDIMMDevice *dimm = PC_DIMM(dev);
PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
MemoryRegion *mr = ddc->get_memory_region(dimm);
@ -1644,7 +1645,8 @@ static void pc_dimm_plug(HotplugHandler *hotplug_dev,
goto out;
}
pc_dimm_memory_plug(dev, &pcms->hotplug_memory, mr, align, &local_err);
pc_dimm_memory_plug(dev, &pcms->hotplug_memory, mr, align,
pcmc->inter_dimm_gap, &local_err);
if (local_err) {
goto out;
}
@ -1945,6 +1947,7 @@ static void pc_machine_class_init(ObjectClass *oc, void *data)
PCMachineClass *pcmc = PC_MACHINE_CLASS(oc);
HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
pcmc->inter_dimm_gap = true;
pcmc->get_hotplug_handler = mc->get_hotplug_handler;
mc->get_hotplug_handler = pc_get_hotpug_handler;
mc->cpu_index_to_socket_id = pc_cpu_index_to_socket_id;

8
hw/i386/pc_piix.c
View file

@ -301,6 +301,13 @@ static void pc_init1(MachineState *machine,
}
}
/* Looking for a pc_compat_2_4() function? It doesn't exist.
* pc_compat_*() functions that run on machine-init time and
* change global QEMU state are deprecated. Please don't create
* one, and implement any pc-*-2.4 (and newer) compat code in
* HW_COMPAT_*, PC_COMPAT_*, or * pc_*_machine_options().
*/
static void pc_compat_2_3(MachineState *machine)
{
PCMachineState *pcms = PC_MACHINE(machine);
@ -482,6 +489,7 @@ static void pc_i440fx_2_4_machine_options(MachineClass *m)
m->alias = NULL;
m->is_default = 0;
pcmc->broken_reserved_end = true;
pcmc->inter_dimm_gap = false;
SET_MACHINE_COMPAT(m, PC_COMPAT_2_4);
}

8
hw/i386/pc_q35.c
View file

@ -284,6 +284,13 @@ static void pc_q35_init(MachineState *machine)
}
}
/* Looking for a pc_compat_2_4() function? It doesn't exist.
* pc_compat_*() functions that run on machine-init time and
* change global QEMU state are deprecated. Please don't create
* one, and implement any pc-*-2.4 (and newer) compat code in
* HW_COMPAT_*, PC_COMPAT_*, or * pc_*_machine_options().
*/
static void pc_compat_2_3(MachineState *machine)
{
PCMachineState *pcms = PC_MACHINE(machine);
@ -385,6 +392,7 @@ static void pc_q35_2_4_machine_options(MachineClass *m)
pc_q35_2_5_machine_options(m);
m->alias = NULL;
pcmc->broken_reserved_end = true;
pcmc->inter_dimm_gap = false;
SET_MACHINE_COMPAT(m, PC_COMPAT_2_4);
}

15
hw/mem/pc-dimm.c
View file

@ -32,7 +32,8 @@ typedef struct pc_dimms_capacity {
} pc_dimms_capacity;
void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
MemoryRegion *mr, uint64_t align, Error **errp)
MemoryRegion *mr, uint64_t align, bool gap,
Error **errp)
{
int slot;
MachineState *machine = MACHINE(qdev_get_machine());
@ -48,7 +49,7 @@ void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
addr = pc_dimm_get_free_addr(hpms->base,
memory_region_size(&hpms->mr),
!addr ? NULL : &addr, align,
!addr ? NULL : &addr, align, gap,
memory_region_size(mr), &local_err);
if (local_err) {
goto out;
@ -287,8 +288,8 @@ static int pc_dimm_built_list(Object *obj, void *opaque)
uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
uint64_t address_space_size,
uint64_t *hint, uint64_t align, uint64_t size,
Error **errp)
uint64_t *hint, uint64_t align, bool gap,
uint64_t size, Error **errp)
{
GSList *list = NULL, *item;
uint64_t new_addr, ret = 0;
@ -333,13 +334,15 @@ uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
goto out;
}
if (ranges_overlap(dimm->addr, dimm_size, new_addr, size)) {
if (ranges_overlap(dimm->addr, dimm_size, new_addr,
size + (gap ? 1 : 0))) {
if (hint) {
DeviceState *d = DEVICE(dimm);
error_setg(errp, "address range conflicts with '%s'", d->id);
goto out;
}
new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size, align);
new_addr = QEMU_ALIGN_UP(dimm->addr + dimm_size + (gap ? 1 : 0),
align);
}
}
ret = new_addr;

8
hw/net/virtio-net.c
View file

@ -1094,13 +1094,7 @@ static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf, size_t
* must have consumed the complete packet.
* Otherwise, drop it. */
if (!n->mergeable_rx_bufs && offset < size) {
#if 0
error_report("virtio-net truncated non-mergeable packet: "
"i %zd mergeable %d offset %zd, size %zd, "
"guest hdr len %zd, host hdr len %zd",
i, n->mergeable_rx_bufs,
offset, size, n->guest_hdr_len, n->host_hdr_len);
#endif
virtqueue_discard(q->rx_vq, &elem, total);
return size;
}

2
hw/ppc/spapr.c
View file

@ -2096,7 +2096,7 @@ static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
goto out;
}
pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err);
pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, false, &local_err);
if (local_err) {
goto out;
}

17
hw/virtio/virtio-pci.c
View file

@ -1491,12 +1491,17 @@ static void virtio_pci_device_plugged(DeviceState *d, Error **errp)
pci_set_long(cfg_mask->pci_cfg_data, ~0x0);
}
if (proxy->nvectors &&
msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
proxy->msix_bar)) {
error_report("unable to init msix vectors to %" PRIu32,
proxy->nvectors);
proxy->nvectors = 0;
if (proxy->nvectors) {
int err = msix_init_exclusive_bar(&proxy->pci_dev, proxy->nvectors,
proxy->msix_bar);
if (err) {
/* Notice when a system that supports MSIx can't initialize it. */
if (err != -ENOTSUP) {
error_report("unable to init msix vectors to %" PRIu32,
proxy->nvectors);
}
proxy->nvectors = 0;
}
}
proxy->pci_dev.config_write = virtio_write_config;

21
hw/virtio/virtio.c
View file

@ -244,14 +244,12 @@ int virtio_queue_empty(VirtQueue *vq)
return vring_avail_idx(vq) == vq->last_avail_idx;
}
void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len, unsigned int idx)
static void virtqueue_unmap_sg(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len)
{
unsigned int offset;
int i;
trace_virtqueue_fill(vq, elem, len, idx);
offset = 0;
for (i = 0; i < elem->in_num; i++) {
size_t size = MIN(len - offset, elem->in_sg[i].iov_len);
@ -267,6 +265,21 @@ void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
cpu_physical_memory_unmap(elem->out_sg[i].iov_base,
elem->out_sg[i].iov_len,
0, elem->out_sg[i].iov_len);
}
void virtqueue_discard(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len)
{
vq->last_avail_idx--;
virtqueue_unmap_sg(vq, elem, len);
}
void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len, unsigned int idx)
{
trace_virtqueue_fill(vq, elem, len, idx);
virtqueue_unmap_sg(vq, elem, len);
idx = (idx + vring_used_idx(vq)) % vq->vring.num;

1
include/hw/i386/pc.h
View file

@ -60,6 +60,7 @@ struct PCMachineClass {
/*< public >*/
bool broken_reserved_end;
bool inter_dimm_gap;
HotplugHandler *(*get_hotplug_handler)(MachineState *machine,
DeviceState *dev);
};

7
include/hw/mem/pc-dimm.h
View file

@ -83,15 +83,16 @@ typedef struct MemoryHotplugState {
uint64_t pc_dimm_get_free_addr(uint64_t address_space_start,
uint64_t address_space_size,
uint64_t *hint, uint64_t align, uint64_t size,
Error **errp);
uint64_t *hint, uint64_t align, bool gap,
uint64_t size, Error **errp);
int pc_dimm_get_free_slot(const int *hint, int max_slots, Error **errp);
int qmp_pc_dimm_device_list(Object *obj, void *opaque);
uint64_t pc_existing_dimms_capacity(Error **errp);
void pc_dimm_memory_plug(DeviceState *dev, MemoryHotplugState *hpms,
MemoryRegion *mr, uint64_t align, Error **errp);
MemoryRegion *mr, uint64_t align, bool gap,
Error **errp);
void pc_dimm_memory_unplug(DeviceState *dev, MemoryHotplugState *hpms,
MemoryRegion *mr);
#endif

2
include/hw/virtio/virtio.h
View file

@ -146,6 +146,8 @@ void virtio_del_queue(VirtIODevice *vdev, int n);
void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len);
void virtqueue_flush(VirtQueue *vq, unsigned int count);
void virtqueue_discard(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len);
void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
unsigned int len, unsigned int idx);

170
tests/vhost-user-test.c
View file

@ -8,7 +8,6 @@
*
*/
#define QEMU_GLIB_COMPAT_H
#include <glib.h>
#include "libqtest.h"
@ -30,12 +29,6 @@
#define HAVE_MONOTONIC_TIME
#endif
#if GLIB_CHECK_VERSION(2, 32, 0)
#define HAVE_MUTEX_INIT
#define HAVE_COND_INIT
#define HAVE_THREAD_NEW
#endif
#define QEMU_CMD_ACCEL " -machine accel=tcg"
#define QEMU_CMD_MEM " -m 512 -object memory-backend-file,id=mem,size=512M,"\
"mem-path=%s,share=on -numa node,memdev=mem"
@ -53,6 +46,8 @@
#define VHOST_MEMORY_MAX_NREGIONS 8
#define VHOST_USER_F_PROTOCOL_FEATURES 30
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
VHOST_USER_GET_FEATURES = 1,
@ -69,6 +64,8 @@ typedef enum VhostUserRequest {
VHOST_USER_SET_VRING_KICK = 12,
VHOST_USER_SET_VRING_CALL = 13,
VHOST_USER_SET_VRING_ERR = 14,
VHOST_USER_GET_PROTOCOL_FEATURES = 15,
VHOST_USER_SET_PROTOCOL_FEATURES = 16,
VHOST_USER_MAX
} VhostUserRequest;
@ -113,93 +110,21 @@ static VhostUserMsg m __attribute__ ((unused));
int fds_num = 0, fds[VHOST_MEMORY_MAX_NREGIONS];
static VhostUserMemory memory;
static GMutex *data_mutex;
static GCond *data_cond;
static CompatGMutex data_mutex;
static CompatGCond data_cond;
static gint64 _get_time(void)
{
#ifdef HAVE_MONOTONIC_TIME
return g_get_monotonic_time();
#else
GTimeVal time;
g_get_current_time(&time);
return time.tv_sec * G_TIME_SPAN_SECOND + time.tv_usec;
#endif
}
static GMutex *_mutex_new(void)
{
GMutex *mutex;
#ifdef HAVE_MUTEX_INIT
mutex = g_new(GMutex, 1);
g_mutex_init(mutex);
#else
mutex = g_mutex_new();
#endif
return mutex;
}
static void _mutex_free(GMutex *mutex)
{
#ifdef HAVE_MUTEX_INIT
g_mutex_clear(mutex);
g_free(mutex);
#else
g_mutex_free(mutex);
#endif
}
static GCond *_cond_new(void)
{
GCond *cond;
#ifdef HAVE_COND_INIT
cond = g_new(GCond, 1);
g_cond_init(cond);
#else
cond = g_cond_new();
#endif
return cond;
}
static gboolean _cond_wait_until(GCond *cond, GMutex *mutex, gint64 end_time)
#if !GLIB_CHECK_VERSION(2, 32, 0)
static gboolean g_cond_wait_until(CompatGCond cond, CompatGMutex mutex,
gint64 end_time)
{
gboolean ret = FALSE;
#ifdef HAVE_COND_INIT
ret = g_cond_wait_until(cond, mutex, end_time);
#else
end_time -= g_get_monotonic_time();
GTimeVal time = { end_time / G_TIME_SPAN_SECOND,
end_time % G_TIME_SPAN_SECOND };
ret = g_cond_timed_wait(cond, mutex, &time);
#endif
return ret;
}
static void _cond_free(GCond *cond)
{
#ifdef HAVE_COND_INIT
g_cond_clear(cond);
g_free(cond);
#else
g_cond_free(cond);
#endif
}
static GThread *_thread_new(const gchar *name, GThreadFunc func, gpointer data)
{
GThread *thread = NULL;
GError *error = NULL;
#ifdef HAVE_THREAD_NEW
thread = g_thread_try_new(name, func, data, &error);
#else
thread = g_thread_create(func, data, TRUE, &error);
#endif
return thread;
}
static void read_guest_mem(void)
{
@ -208,11 +133,11 @@ static void read_guest_mem(void)
int i, j;
size_t size;
g_mutex_lock(data_mutex);
g_mutex_lock(&data_mutex);
end_time = _get_time() + 5 * G_TIME_SPAN_SECOND;
end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
while (!fds_num) {
if (!_cond_wait_until(data_cond, data_mutex, end_time)) {
if (!g_cond_wait_until(&data_cond, &data_mutex, end_time)) {
/* timeout has passed */
g_assert(fds_num);
break;
@ -252,7 +177,7 @@ static void read_guest_mem(void)
}
g_assert_cmpint(1, ==, 1);
g_mutex_unlock(data_mutex);
g_mutex_unlock(&data_mutex);
}
static void *thread_function(void *data)
@ -280,7 +205,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
return;
}
g_mutex_lock(data_mutex);
g_mutex_lock(&data_mutex);
memcpy(p, buf, VHOST_USER_HDR_SIZE);
if (msg.size) {
@ -290,6 +215,20 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
switch (msg.request) {
case VHOST_USER_GET_FEATURES:
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.u64);
msg.u64 = 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
case VHOST_USER_SET_FEATURES:
g_assert_cmpint(msg.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
!=, 0ULL);
break;
case VHOST_USER_GET_PROTOCOL_FEATURES:
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.u64);
@ -313,7 +252,7 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
fds_num = qemu_chr_fe_get_msgfds(chr, fds, sizeof(fds) / sizeof(int));
/* signal the test that it can continue */
g_cond_signal(data_cond);
g_cond_signal(&data_cond);
break;
case VHOST_USER_SET_VRING_KICK:
@ -330,20 +269,14 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
default:
break;
}
g_mutex_unlock(data_mutex);
g_mutex_unlock(&data_mutex);
}
static const char *init_hugepagefs(void)
static const char *init_hugepagefs(const char *path)
{
const char *path;
struct statfs fs;
int ret;
path = getenv("QTEST_HUGETLBFS_PATH");
if (!path) {
path = "/hugetlbfs";
}
if (access(path, R_OK | W_OK | X_OK)) {
g_test_message("access on path (%s): %s\n", path, strerror(errno));
return NULL;
@ -370,22 +303,34 @@ int main(int argc, char **argv)
{
QTestState *s = NULL;
CharDriverState *chr = NULL;
const char *hugefs = 0;
const char *hugefs;
char *socket_path = 0;
char *qemu_cmd = 0;
char *chr_path = 0;
int ret;
char template[] = "/tmp/vhost-test-XXXXXX";
const char *tmpfs;
const char *root;
g_test_init(&argc, &argv, NULL);
module_call_init(MODULE_INIT_QOM);
hugefs = init_hugepagefs();
if (!hugefs) {
return 0;
tmpfs = mkdtemp(template);
if (!tmpfs) {
g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
}
g_assert(tmpfs);
hugefs = getenv("QTEST_HUGETLBFS_PATH");
if (hugefs) {
root = init_hugepagefs(hugefs);
g_assert(root);
} else {
root = tmpfs;
}
socket_path = g_strdup_printf("/tmp/vhost-%d.sock", getpid());
socket_path = g_strdup_printf("%s/vhost.sock", tmpfs);
/* create char dev and add read handlers */
qemu_add_opts(&qemu_chardev_opts);
@ -395,11 +340,11 @@ int main(int argc, char **argv)
qemu_chr_add_handlers(chr, chr_can_read, chr_read, NULL, chr);
/* run the main loop thread so the chardev may operate */
data_mutex = _mutex_new();
data_cond = _cond_new();
_thread_new(NULL, thread_function, NULL);
g_mutex_init(&data_mutex);
g_cond_init(&data_cond);
g_thread_new(NULL, thread_function, NULL);
qemu_cmd = g_strdup_printf(QEMU_CMD, hugefs, socket_path);
qemu_cmd = g_strdup_printf(QEMU_CMD, root, socket_path);
s = qtest_start(qemu_cmd);
g_free(qemu_cmd);
@ -414,8 +359,13 @@ int main(int argc, char **argv)
/* cleanup */
unlink(socket_path);
g_free(socket_path);
_cond_free(data_cond);
_mutex_free(data_mutex);
ret = rmdir(tmpfs);
if (ret != 0) {
g_test_message("unable to rmdir: path (%s): %s\n",
tmpfs, strerror(errno));
}
g_assert_cmpint(ret, ==, 0);
return ret;
}

20
util/oslib-posix.c
View file

@ -128,10 +128,10 @@ void *qemu_memalign(size_t alignment, size_t size)
void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment)
{
size_t align = QEMU_VMALLOC_ALIGN;
size_t total = size + align - getpagesize();
void *ptr = mmap(0, total, PROT_READ | PROT_WRITE,
MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
size_t total = size + align;
void *ptr = mmap(0, total, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
size_t offset = QEMU_ALIGN_UP((uintptr_t)ptr, align) - (uintptr_t)ptr;
void *ptr1;
if (ptr == MAP_FAILED) {
return NULL;
@ -140,14 +140,22 @@ void *qemu_anon_ram_alloc(size_t size, uint64_t *alignment)
if (alignment) {
*alignment = align;
}
ptr1 = mmap(ptr + offset, size, PROT_READ | PROT_WRITE,
MAP_FIXED | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (ptr1 == MAP_FAILED) {
munmap(ptr, total);
return NULL;
}
ptr += offset;
total -= offset;
if (offset > 0) {
munmap(ptr - offset, offset);
}
if (total > size) {
munmap(ptr + size, total - size);
if (total > size + getpagesize()) {
munmap(ptr + size + getpagesize(), total - size - getpagesize());
}
trace_qemu_anon_ram_alloc(size, ptr);
@ -164,7 +172,7 @@ void qemu_anon_ram_free(void *ptr, size_t size)
{
trace_qemu_anon_ram_free(ptr, size);
if (ptr) {
munmap(ptr, size);
munmap(ptr, size + getpagesize());
}
}