mirrors/qemu
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
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());
}
}