ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

virtio-mem: Simplify bitmap handling and virtio_mem_set_block_state() 

Let's separate plug and unplug handling to prepare for future changes
and make the code a bit easier to read -- working on block states
(plugged/unplugged) instead of on a bitmap.

Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Gavin Shan <gshan@redhat.com>
Signed-off-by: David Hildenbrand <david@redhat.com>
Message-Id: <20230523183036.517957-1-david@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
David Hildenbrand 2023-05-23 20:30:36 +02:00 committed by Michael S. Tsirkin
parent 8eb85fb5ac
commit 25c893037b
1 changed files with 64 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
hw/virtio/virtio-mem.c
View File

@ -398,33 +398,46 @@ static void virtio_mem_notify_unplug_all(VirtIOMEM *vmem)
} }
} }
static bool virtio_mem_test_bitmap(const VirtIOMEM *vmem, uint64_t start_gpa, static bool virtio_mem_is_range_plugged(const VirtIOMEM *vmem,
uint64_t size, bool plugged) uint64_t start_gpa, uint64_t size)
{ {
const unsigned long first_bit = (start_gpa - vmem->addr) / vmem->block_size; const unsigned long first_bit = (start_gpa - vmem->addr) / vmem->block_size;
const unsigned long last_bit = first_bit + (size / vmem->block_size) - 1; const unsigned long last_bit = first_bit + (size / vmem->block_size) - 1;
unsigned long found_bit; unsigned long found_bit;
/* We fake a shorter bitmap to avoid searching too far. */ /* We fake a shorter bitmap to avoid searching too far. */
if (plugged) { found_bit = find_next_zero_bit(vmem->bitmap, last_bit + 1, first_bit);
found_bit = find_next_zero_bit(vmem->bitmap, last_bit + 1, first_bit);
} else {
found_bit = find_next_bit(vmem->bitmap, last_bit + 1, first_bit);
}
return found_bit > last_bit; return found_bit > last_bit;
} }
static void virtio_mem_set_bitmap(VirtIOMEM *vmem, uint64_t start_gpa, static bool virtio_mem_is_range_unplugged(const VirtIOMEM *vmem,
uint64_t size, bool plugged) uint64_t start_gpa, uint64_t size)
{
const unsigned long first_bit = (start_gpa - vmem->addr) / vmem->block_size;
const unsigned long last_bit = first_bit + (size / vmem->block_size) - 1;
unsigned long found_bit;
/* We fake a shorter bitmap to avoid searching too far. */
found_bit = find_next_bit(vmem->bitmap, last_bit + 1, first_bit);
return found_bit > last_bit;
}
static void virtio_mem_set_range_plugged(VirtIOMEM *vmem, uint64_t start_gpa,
uint64_t size)
{ {
const unsigned long bit = (start_gpa - vmem->addr) / vmem->block_size; const unsigned long bit = (start_gpa - vmem->addr) / vmem->block_size;
const unsigned long nbits = size / vmem->block_size; const unsigned long nbits = size / vmem->block_size;
if (plugged) { bitmap_set(vmem->bitmap, bit, nbits);
bitmap_set(vmem->bitmap, bit, nbits); }
} else {
bitmap_clear(vmem->bitmap, bit, nbits); static void virtio_mem_set_range_unplugged(VirtIOMEM *vmem, uint64_t start_gpa,
} uint64_t size)
{
const unsigned long bit = (start_gpa - vmem->addr) / vmem->block_size;
const unsigned long nbits = size / vmem->block_size;
bitmap_clear(vmem->bitmap, bit, nbits);
} }
static void virtio_mem_send_response(VirtIOMEM *vmem, VirtQueueElement *elem, static void virtio_mem_send_response(VirtIOMEM *vmem, VirtQueueElement *elem,
@ -474,6 +487,7 @@ static int virtio_mem_set_block_state(VirtIOMEM *vmem, uint64_t start_gpa,
{ {
const uint64_t offset = start_gpa - vmem->addr; const uint64_t offset = start_gpa - vmem->addr;
RAMBlock *rb = vmem->memdev->mr.ram_block; RAMBlock *rb = vmem->memdev->mr.ram_block;
int ret = 0;
if (virtio_mem_is_busy()) { if (virtio_mem_is_busy()) {
return -EBUSY; return -EBUSY;
@ -484,42 +498,43 @@ static int virtio_mem_set_block_state(VirtIOMEM *vmem, uint64_t start_gpa,
return -EBUSY; return -EBUSY;
} }
virtio_mem_notify_unplug(vmem, offset, size); virtio_mem_notify_unplug(vmem, offset, size);
} else { virtio_mem_set_range_unplugged(vmem, start_gpa, size);
int ret = 0; return 0;
}
if (vmem->prealloc) { if (vmem->prealloc) {
void *area = memory_region_get_ram_ptr(&vmem->memdev->mr) + offset; void *area = memory_region_get_ram_ptr(&vmem->memdev->mr) + offset;
int fd = memory_region_get_fd(&vmem->memdev->mr); int fd = memory_region_get_fd(&vmem->memdev->mr);
Error *local_err = NULL; Error *local_err = NULL;
qemu_prealloc_mem(fd, area, size, 1, NULL, &local_err); qemu_prealloc_mem(fd, area, size, 1, NULL, &local_err);
if (local_err) { if (local_err) {
static bool warned; static bool warned;
/* /*
* Warn only once, we don't want to fill the log with these * Warn only once, we don't want to fill the log with these
* warnings. * warnings.
*/ */
if (!warned) { if (!warned) {
warn_report_err(local_err); warn_report_err(local_err);
warned = true; warned = true;
} else { } else {
error_free(local_err); error_free(local_err);
}
ret = -EBUSY;
} }
} ret = -EBUSY;
if (!ret) {
ret = virtio_mem_notify_plug(vmem, offset, size);
}
if (ret) {
/* Could be preallocation or a notifier populated memory. */
ram_block_discard_range(vmem->memdev->mr.ram_block, offset, size);
return -EBUSY;
} }
} }
virtio_mem_set_bitmap(vmem, start_gpa, size, plug);
if (!ret) {
ret = virtio_mem_notify_plug(vmem, offset, size);
}
if (ret) {
/* Could be preallocation or a notifier populated memory. */
ram_block_discard_range(vmem->memdev->mr.ram_block, offset, size);
return -EBUSY;
}
virtio_mem_set_range_plugged(vmem, start_gpa, size);
return 0; return 0;
} }
@ -538,7 +553,8 @@ static int virtio_mem_state_change_request(VirtIOMEM *vmem, uint64_t gpa,
} }
/* test if really all blocks are in the opposite state */ /* test if really all blocks are in the opposite state */
if (!virtio_mem_test_bitmap(vmem, gpa, size, !plug)) { if ((plug && !virtio_mem_is_range_unplugged(vmem, gpa, size)) ||
(!plug && !virtio_mem_is_range_plugged(vmem, gpa, size))) {
return VIRTIO_MEM_RESP_ERROR; return VIRTIO_MEM_RESP_ERROR;
} }
@ -651,9 +667,9 @@ static void virtio_mem_state_request(VirtIOMEM *vmem, VirtQueueElement *elem,
return; return;
} }
if (virtio_mem_test_bitmap(vmem, gpa, size, true)) { if (virtio_mem_is_range_plugged(vmem, gpa, size)) {
resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_PLUGGED); resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_PLUGGED);
} else if (virtio_mem_test_bitmap(vmem, gpa, size, false)) { } else if (virtio_mem_is_range_unplugged(vmem, gpa, size)) {
resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_UNPLUGGED); resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_UNPLUGGED);
} else { } else {
resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_MIXED); resp.u.state.state = cpu_to_le16(VIRTIO_MEM_STATE_MIXED);
@ -1372,7 +1388,7 @@ static bool virtio_mem_rdm_is_populated(const RamDiscardManager *rdm,
return false; return false;
} }
return virtio_mem_test_bitmap(vmem, start_gpa, end_gpa - start_gpa, true); return virtio_mem_is_range_plugged(vmem, start_gpa, end_gpa - start_gpa);
} }
struct VirtIOMEMReplayData { struct VirtIOMEMReplayData {