[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH v2 fixed 14/16] util: vfio-helpers: Implement ram_block_resized()
From: |
David Hildenbrand |
Subject: |
[PATCH v2 fixed 14/16] util: vfio-helpers: Implement ram_block_resized() |
Date: |
Wed, 12 Feb 2020 14:42:52 +0100 |
Let's implement ram_block_resized(), allowing resizable mappings.
For resizable mappings, we reserve $max_size IOVA address space, but only
map $size of it. When resizing, unmap the old part and remap the new
part. We'll need a new ioctl to do this atomically (e.g., to resize
while the guest is running - not allowed for now).
Cc: Richard Henderson <address@hidden>
Cc: Paolo Bonzini <address@hidden>
Cc: Eduardo Habkost <address@hidden>
Cc: Marcel Apfelbaum <address@hidden>
Cc: Alex Williamson <address@hidden>
Cc: Stefan Hajnoczi <address@hidden>
Cc: "Dr. David Alan Gilbert" <address@hidden>
Signed-off-by: David Hildenbrand <address@hidden>
---
util/trace-events | 5 ++--
util/vfio-helpers.c | 70 ++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 66 insertions(+), 9 deletions(-)
diff --git a/util/trace-events b/util/trace-events
index 83b6639018..88b7dbf4a5 100644
--- a/util/trace-events
+++ b/util/trace-events
@@ -74,8 +74,9 @@ qemu_mutex_unlock(void *mutex, const char *file, const int
line) "released mutex
# vfio-helpers.c
qemu_vfio_dma_reset_temporary(void *s) "s %p"
-qemu_vfio_ram_block_added(void *s, void *p, size_t size) "s %p host %p size
0x%zx"
-qemu_vfio_ram_block_removed(void *s, void *p, size_t size) "s %p host %p size
0x%zx"
+qemu_vfio_ram_block_added(void *s, void *p, size_t size, size_t max_size) "s
%p host %p size 0x%zx max_size 0x%zx"
+qemu_vfio_ram_block_removed(void *s, void *p, size_t size, size_t max_size) "s
%p host %p size 0x%zx max_size 0x%zx"
+qemu_vfio_ram_block_resized(void *s, void *p, size_t old_size, size_t
new_sizze) "s %p host %p old_size 0x%zx new_size 0x%zx"
qemu_vfio_find_mapping(void *s, void *p) "s %p host %p"
qemu_vfio_new_mapping(void *s, void *host, size_t size, int index, uint64_t
iova) "s %p host %p size %zu index %d iova 0x%"PRIx64
qemu_vfio_do_mapping(void *s, void *host, size_t size, uint64_t iova) "s %p
host %p size %zu iova 0x%"PRIx64
diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index 3db6aa49f4..70877b9ebd 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -372,14 +372,20 @@ fail_container:
return ret;
}
+static int qemu_vfio_dma_map_resizable(QEMUVFIOState *s, void *host,
+ size_t size, size_t max_size,
+ bool temporary, uint64_t *iova);
+static void qemu_vfio_dma_map_resize(QEMUVFIOState *s, void *host,
+ size_t old_size, size_t new_size);
+
static void qemu_vfio_ram_block_added(RAMBlockNotifier *n, void *host,
size_t size, size_t max_size)
{
QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
int ret;
- trace_qemu_vfio_ram_block_added(s, host, max_size);
- ret = qemu_vfio_dma_map(s, host, max_size, false, NULL);
+ trace_qemu_vfio_ram_block_added(s, host, size, max_size);
+ ret = qemu_vfio_dma_map_resizable(s, host, size, max_size, false, NULL);
if (ret) {
error_report("qemu_vfio_dma_map(%p, %zu) failed: %d", host,
max_size, ret);
@@ -391,16 +397,28 @@ static void qemu_vfio_ram_block_removed(RAMBlockNotifier
*n, void *host,
{
QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
if (host) {
- trace_qemu_vfio_ram_block_removed(s, host, max_size);
+ trace_qemu_vfio_ram_block_removed(s, host, size, max_size);
qemu_vfio_dma_unmap(s, host);
}
}
+static void qemu_vfio_ram_block_resized(RAMBlockNotifier *n, void *host,
+ size_t old_size, size_t new_size)
+{
+ QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
+
+ if (host) {
+ trace_qemu_vfio_ram_block_resized(s, host, old_size, new_size);
+ qemu_vfio_dma_map_resize(s, host, old_size, new_size);
+ }
+}
+
static void qemu_vfio_open_common(QEMUVFIOState *s)
{
qemu_mutex_init(&s->lock);
s->ram_notifier.ram_block_added = qemu_vfio_ram_block_added;
s->ram_notifier.ram_block_removed = qemu_vfio_ram_block_removed;
+ s->ram_notifier.ram_block_resized = qemu_vfio_ram_block_resized;
s->low_water_mark = QEMU_VFIO_IOVA_MIN;
s->high_water_mark = QEMU_VFIO_IOVA_MAX;
ram_block_notifier_add(&s->ram_notifier);
@@ -597,9 +615,14 @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
* the result in @iova if not NULL. The caller need to make sure the area is
* aligned to page size, and mustn't overlap with existing mapping areas (split
* mapping status within this area is not allowed).
+ *
+ * If size < max_size, a region of max_size in IOVA address is reserved, such
+ * that the mapping can later be resized. Resizable mappings are only allowed
+ * for !temporary mappings.
*/
-int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
- bool temporary, uint64_t *iova)
+static int qemu_vfio_dma_map_resizable(QEMUVFIOState *s, void *host,
+ size_t size, size_t max_size,
+ bool temporary, uint64_t *iova)
{
int ret = 0;
int index;
@@ -608,13 +631,17 @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host,
size_t size,
assert(QEMU_PTR_IS_ALIGNED(host, qemu_real_host_page_size));
assert(QEMU_IS_ALIGNED(size, qemu_real_host_page_size));
+ assert(QEMU_IS_ALIGNED(max_size, qemu_real_host_page_size));
+ assert(size == max_size || !temporary);
+ assert(size <= max_size);
+
trace_qemu_vfio_dma_map(s, host, size, temporary, iova);
qemu_mutex_lock(&s->lock);
mapping = qemu_vfio_find_mapping(s, host, &index);
if (mapping) {
iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
} else {
- if (s->high_water_mark - s->low_water_mark + 1 < size) {
+ if (s->high_water_mark - s->low_water_mark + 1 < max_size) {
ret = -ENOMEM;
goto out;
}
@@ -631,7 +658,7 @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t
size,
qemu_vfio_remove_mapping(s, mapping);
goto out;
}
- s->low_water_mark += size;
+ s->low_water_mark += max_size;
qemu_vfio_dump_mappings(s);
} else {
iova0 = s->high_water_mark - size;
@@ -650,6 +677,12 @@ out:
return ret;
}
+int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+ bool temporary, uint64_t *iova)
+{
+ return qemu_vfio_dma_map_resizable(s, host, size, size, temporary, iova);
+}
+
/* Reset the high watermark and free all "temporary" mappings. */
int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s)
{
@@ -694,6 +727,29 @@ out:
qemu_mutex_unlock(&s->lock);
}
+static void qemu_vfio_dma_map_resize(QEMUVFIOState *s, void *host,
+ size_t old_size, size_t new_size)
+{
+ IOVAMapping *m;
+ int index = 0;
+
+ qemu_mutex_lock(&s->lock);
+ m = qemu_vfio_find_mapping(s, host, &index);
+ if (!m) {
+ return;
+ }
+ assert(m->size == old_size);
+
+ /* Note: Not atomic - we need a new ioctl for that. */
+ qemu_vfio_undo_mapping(s, m->iova, m->size);
+ qemu_vfio_do_mapping(s, host, m->iova, new_size);
+
+ m->size = new_size;
+ assert(qemu_vfio_verify_mappings(s));
+
+ qemu_mutex_unlock(&s->lock);
+}
+
static void qemu_vfio_reset(QEMUVFIOState *s)
{
ioctl(s->device, VFIO_DEVICE_RESET);
--
2.24.1
- [PATCH v2 fixed 06/16] exec: Reuse qemu_ram_apply_settings() in qemu_ram_remap(), (continued)
- [PATCH v2 fixed 06/16] exec: Reuse qemu_ram_apply_settings() in qemu_ram_remap(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 05/16] exec: Factor out setting ram settings (madvise ...) into qemu_ram_apply_settings(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 07/16] exec: Drop "shared" parameter from ram_block_add(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 08/16] util/mmap-alloc: Factor out calculation of pagesize to mmap_pagesize(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 09/16] util/mmap-alloc: Factor out reserving of a memory region to mmap_reserve(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 10/16] util/mmap-alloc: Factor out populating of memory to mmap_populate(), David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 11/16] util/mmap-alloc: Prepare for resizable mmaps, David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 12/16] util/mmap-alloc: Implement resizable mmaps, David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 13/16] numa: Teach ram block notifiers about resizable ram blocks, David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 14/16] util: vfio-helpers: Implement ram_block_resized(),
David Hildenbrand <=
- [PATCH v2 fixed 15/16] util: oslib: Resizable anonymous allocations under POSIX, David Hildenbrand, 2020/02/12
- [PATCH v2 fixed 16/16] exec: Ram blocks with resizable anonymous allocations under POSIX, David Hildenbrand, 2020/02/12
- Re: [PATCH v2 fixed 00/16] Ram blocks with resizable anonymous allocations under POSIX, David Hildenbrand, 2020/02/12