4 * Copyright (C) 2020 Red Hat, Inc.
7 * David Hildenbrand <david@redhat.com>
9 * This work is licensed under the terms of the GNU GPL, version 2.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "qemu-common.h"
16 #include "qemu/cutils.h"
17 #include "qemu/error-report.h"
18 #include "qemu/units.h"
19 #include "sysemu/numa.h"
20 #include "sysemu/sysemu.h"
21 #include "sysemu/reset.h"
22 #include "hw/virtio/virtio.h"
23 #include "hw/virtio/virtio-bus.h"
24 #include "hw/virtio/virtio-access.h"
25 #include "hw/virtio/virtio-mem.h"
26 #include "qapi/error.h"
27 #include "qapi/visitor.h"
28 #include "exec/ram_addr.h"
29 #include "migration/misc.h"
30 #include "hw/boards.h"
31 #include "hw/qdev-properties.h"
32 #include CONFIG_DEVICES
36 * Use QEMU_VMALLOC_ALIGN, so no THP will have to be split when unplugging
37 * memory (e.g., 2MB on x86_64).
39 #define VIRTIO_MEM_MIN_BLOCK_SIZE ((uint32_t)QEMU_VMALLOC_ALIGN)
41 * Size the usable region bigger than the requested size if possible. Esp.
42 * Linux guests will only add (aligned) memory blocks in case they fully
43 * fit into the usable region, but plug+online only a subset of the pages.
44 * The memory block size corresponds mostly to the section size.
46 * This allows e.g., to add 20MB with a section size of 128MB on x86_64, and
47 * a section size of 1GB on arm64 (as long as the start address is properly
48 * aligned, similar to ordinary DIMMs).
50 * We can change this at any time and maybe even make it configurable if
51 * necessary (as the section size can change). But it's more likely that the
52 * section size will rather get smaller and not bigger over time.
54 #if defined(TARGET_X86_64) || defined(TARGET_I386)
55 #define VIRTIO_MEM_USABLE_EXTENT (2 * (128 * MiB))
57 #error VIRTIO_MEM_USABLE_EXTENT not defined
60 static bool virtio_mem_is_busy(void)
63 * Postcopy cannot handle concurrent discards and we don't want to migrate
64 * pages on-demand with stale content when plugging new blocks.
66 * For precopy, we don't want unplugged blocks in our migration stream, and
67 * when plugging new blocks, the page content might differ between source
68 * and destination (observable by the guest when not initializing pages
69 * after plugging them) until we're running on the destination (as we didn't
70 * migrate these blocks when they were unplugged).
72 return migration_in_incoming_postcopy() || !migration_is_idle();
75 static bool virtio_mem_test_bitmap(VirtIOMEM
*vmem
, uint64_t start_gpa
,
76 uint64_t size
, bool plugged
)
78 const unsigned long first_bit
= (start_gpa
- vmem
->addr
) / vmem
->block_size
;
79 const unsigned long last_bit
= first_bit
+ (size
/ vmem
->block_size
) - 1;
80 unsigned long found_bit
;
82 /* We fake a shorter bitmap to avoid searching too far. */
84 found_bit
= find_next_zero_bit(vmem
->bitmap
, last_bit
+ 1, first_bit
);
86 found_bit
= find_next_bit(vmem
->bitmap
, last_bit
+ 1, first_bit
);
88 return found_bit
> last_bit
;
91 static void virtio_mem_set_bitmap(VirtIOMEM
*vmem
, uint64_t start_gpa
,
92 uint64_t size
, bool plugged
)
94 const unsigned long bit
= (start_gpa
- vmem
->addr
) / vmem
->block_size
;
95 const unsigned long nbits
= size
/ vmem
->block_size
;
98 bitmap_set(vmem
->bitmap
, bit
, nbits
);
100 bitmap_clear(vmem
->bitmap
, bit
, nbits
);
104 static void virtio_mem_send_response(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
105 struct virtio_mem_resp
*resp
)
107 VirtIODevice
*vdev
= VIRTIO_DEVICE(vmem
);
108 VirtQueue
*vq
= vmem
->vq
;
110 trace_virtio_mem_send_response(le16_to_cpu(resp
->type
));
111 iov_from_buf(elem
->in_sg
, elem
->in_num
, 0, resp
, sizeof(*resp
));
113 virtqueue_push(vq
, elem
, sizeof(*resp
));
114 virtio_notify(vdev
, vq
);
117 static void virtio_mem_send_response_simple(VirtIOMEM
*vmem
,
118 VirtQueueElement
*elem
,
121 struct virtio_mem_resp resp
= {
122 .type
= cpu_to_le16(type
),
125 virtio_mem_send_response(vmem
, elem
, &resp
);
128 static bool virtio_mem_valid_range(VirtIOMEM
*vmem
, uint64_t gpa
, uint64_t size
)
130 if (!QEMU_IS_ALIGNED(gpa
, vmem
->block_size
)) {
133 if (gpa
+ size
< gpa
|| !size
) {
136 if (gpa
< vmem
->addr
|| gpa
>= vmem
->addr
+ vmem
->usable_region_size
) {
139 if (gpa
+ size
> vmem
->addr
+ vmem
->usable_region_size
) {
145 static int virtio_mem_set_block_state(VirtIOMEM
*vmem
, uint64_t start_gpa
,
146 uint64_t size
, bool plug
)
148 const uint64_t offset
= start_gpa
- vmem
->addr
;
151 if (virtio_mem_is_busy()) {
156 ret
= ram_block_discard_range(vmem
->memdev
->mr
.ram_block
, offset
, size
);
158 error_report("Unexpected error discarding RAM: %s",
163 virtio_mem_set_bitmap(vmem
, start_gpa
, size
, plug
);
167 static int virtio_mem_state_change_request(VirtIOMEM
*vmem
, uint64_t gpa
,
168 uint16_t nb_blocks
, bool plug
)
170 const uint64_t size
= nb_blocks
* vmem
->block_size
;
173 if (!virtio_mem_valid_range(vmem
, gpa
, size
)) {
174 return VIRTIO_MEM_RESP_ERROR
;
177 if (plug
&& (vmem
->size
+ size
> vmem
->requested_size
)) {
178 return VIRTIO_MEM_RESP_NACK
;
181 /* test if really all blocks are in the opposite state */
182 if (!virtio_mem_test_bitmap(vmem
, gpa
, size
, !plug
)) {
183 return VIRTIO_MEM_RESP_ERROR
;
186 ret
= virtio_mem_set_block_state(vmem
, gpa
, size
, plug
);
188 return VIRTIO_MEM_RESP_BUSY
;
195 notifier_list_notify(&vmem
->size_change_notifiers
, &vmem
->size
);
196 return VIRTIO_MEM_RESP_ACK
;
199 static void virtio_mem_plug_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
200 struct virtio_mem_req
*req
)
202 const uint64_t gpa
= le64_to_cpu(req
->u
.plug
.addr
);
203 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.plug
.nb_blocks
);
206 trace_virtio_mem_plug_request(gpa
, nb_blocks
);
207 type
= virtio_mem_state_change_request(vmem
, gpa
, nb_blocks
, true);
208 virtio_mem_send_response_simple(vmem
, elem
, type
);
211 static void virtio_mem_unplug_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
212 struct virtio_mem_req
*req
)
214 const uint64_t gpa
= le64_to_cpu(req
->u
.unplug
.addr
);
215 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.unplug
.nb_blocks
);
218 trace_virtio_mem_unplug_request(gpa
, nb_blocks
);
219 type
= virtio_mem_state_change_request(vmem
, gpa
, nb_blocks
, false);
220 virtio_mem_send_response_simple(vmem
, elem
, type
);
223 static void virtio_mem_resize_usable_region(VirtIOMEM
*vmem
,
224 uint64_t requested_size
,
227 uint64_t newsize
= MIN(memory_region_size(&vmem
->memdev
->mr
),
228 requested_size
+ VIRTIO_MEM_USABLE_EXTENT
);
230 if (!requested_size
) {
234 if (newsize
< vmem
->usable_region_size
&& !can_shrink
) {
238 trace_virtio_mem_resized_usable_region(vmem
->usable_region_size
, newsize
);
239 vmem
->usable_region_size
= newsize
;
242 static int virtio_mem_unplug_all(VirtIOMEM
*vmem
)
244 RAMBlock
*rb
= vmem
->memdev
->mr
.ram_block
;
247 if (virtio_mem_is_busy()) {
251 ret
= ram_block_discard_range(rb
, 0, qemu_ram_get_used_length(rb
));
253 error_report("Unexpected error discarding RAM: %s", strerror(-ret
));
256 bitmap_clear(vmem
->bitmap
, 0, vmem
->bitmap_size
);
259 notifier_list_notify(&vmem
->size_change_notifiers
, &vmem
->size
);
261 trace_virtio_mem_unplugged_all();
262 virtio_mem_resize_usable_region(vmem
, vmem
->requested_size
, true);
266 static void virtio_mem_unplug_all_request(VirtIOMEM
*vmem
,
267 VirtQueueElement
*elem
)
269 trace_virtio_mem_unplug_all_request();
270 if (virtio_mem_unplug_all(vmem
)) {
271 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_BUSY
);
273 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_ACK
);
277 static void virtio_mem_state_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
278 struct virtio_mem_req
*req
)
280 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.state
.nb_blocks
);
281 const uint64_t gpa
= le64_to_cpu(req
->u
.state
.addr
);
282 const uint64_t size
= nb_blocks
* vmem
->block_size
;
283 struct virtio_mem_resp resp
= {
284 .type
= cpu_to_le16(VIRTIO_MEM_RESP_ACK
),
287 trace_virtio_mem_state_request(gpa
, nb_blocks
);
288 if (!virtio_mem_valid_range(vmem
, gpa
, size
)) {
289 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_ERROR
);
293 if (virtio_mem_test_bitmap(vmem
, gpa
, size
, true)) {
294 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_PLUGGED
);
295 } else if (virtio_mem_test_bitmap(vmem
, gpa
, size
, false)) {
296 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_UNPLUGGED
);
298 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_MIXED
);
300 trace_virtio_mem_state_response(le16_to_cpu(resp
.u
.state
.state
));
301 virtio_mem_send_response(vmem
, elem
, &resp
);
304 static void virtio_mem_handle_request(VirtIODevice
*vdev
, VirtQueue
*vq
)
306 const int len
= sizeof(struct virtio_mem_req
);
307 VirtIOMEM
*vmem
= VIRTIO_MEM(vdev
);
308 VirtQueueElement
*elem
;
309 struct virtio_mem_req req
;
313 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
318 if (iov_to_buf(elem
->out_sg
, elem
->out_num
, 0, &req
, len
) < len
) {
319 virtio_error(vdev
, "virtio-mem protocol violation: invalid request"
321 virtqueue_detach_element(vq
, elem
, 0);
326 if (iov_size(elem
->in_sg
, elem
->in_num
) <
327 sizeof(struct virtio_mem_resp
)) {
328 virtio_error(vdev
, "virtio-mem protocol violation: not enough space"
329 " for response: %zu",
330 iov_size(elem
->in_sg
, elem
->in_num
));
331 virtqueue_detach_element(vq
, elem
, 0);
336 type
= le16_to_cpu(req
.type
);
338 case VIRTIO_MEM_REQ_PLUG
:
339 virtio_mem_plug_request(vmem
, elem
, &req
);
341 case VIRTIO_MEM_REQ_UNPLUG
:
342 virtio_mem_unplug_request(vmem
, elem
, &req
);
344 case VIRTIO_MEM_REQ_UNPLUG_ALL
:
345 virtio_mem_unplug_all_request(vmem
, elem
);
347 case VIRTIO_MEM_REQ_STATE
:
348 virtio_mem_state_request(vmem
, elem
, &req
);
351 virtio_error(vdev
, "virtio-mem protocol violation: unknown request"
353 virtqueue_detach_element(vq
, elem
, 0);
362 static void virtio_mem_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
364 VirtIOMEM
*vmem
= VIRTIO_MEM(vdev
);
365 struct virtio_mem_config
*config
= (void *) config_data
;
367 config
->block_size
= cpu_to_le64(vmem
->block_size
);
368 config
->node_id
= cpu_to_le16(vmem
->node
);
369 config
->requested_size
= cpu_to_le64(vmem
->requested_size
);
370 config
->plugged_size
= cpu_to_le64(vmem
->size
);
371 config
->addr
= cpu_to_le64(vmem
->addr
);
372 config
->region_size
= cpu_to_le64(memory_region_size(&vmem
->memdev
->mr
));
373 config
->usable_region_size
= cpu_to_le64(vmem
->usable_region_size
);
376 static uint64_t virtio_mem_get_features(VirtIODevice
*vdev
, uint64_t features
,
379 MachineState
*ms
= MACHINE(qdev_get_machine());
381 if (ms
->numa_state
) {
382 #if defined(CONFIG_ACPI)
383 virtio_add_feature(&features
, VIRTIO_MEM_F_ACPI_PXM
);
389 static void virtio_mem_system_reset(void *opaque
)
391 VirtIOMEM
*vmem
= VIRTIO_MEM(opaque
);
394 * During usual resets, we will unplug all memory and shrink the usable
395 * region size. This is, however, not possible in all scenarios. Then,
396 * the guest has to deal with this manually (VIRTIO_MEM_REQ_UNPLUG_ALL).
398 virtio_mem_unplug_all(vmem
);
401 static void virtio_mem_device_realize(DeviceState
*dev
, Error
**errp
)
403 MachineState
*ms
= MACHINE(qdev_get_machine());
404 int nb_numa_nodes
= ms
->numa_state
? ms
->numa_state
->num_nodes
: 0;
405 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
406 VirtIOMEM
*vmem
= VIRTIO_MEM(dev
);
412 error_setg(errp
, "'%s' property is not set", VIRTIO_MEM_MEMDEV_PROP
);
414 } else if (host_memory_backend_is_mapped(vmem
->memdev
)) {
415 error_setg(errp
, "'%s' property specifies a busy memdev: %s",
416 VIRTIO_MEM_MEMDEV_PROP
,
417 object_get_canonical_path_component(OBJECT(vmem
->memdev
)));
419 } else if (!memory_region_is_ram(&vmem
->memdev
->mr
) ||
420 memory_region_is_rom(&vmem
->memdev
->mr
) ||
421 !vmem
->memdev
->mr
.ram_block
) {
422 error_setg(errp
, "'%s' property specifies an unsupported memdev",
423 VIRTIO_MEM_MEMDEV_PROP
);
427 if ((nb_numa_nodes
&& vmem
->node
>= nb_numa_nodes
) ||
428 (!nb_numa_nodes
&& vmem
->node
)) {
429 error_setg(errp
, "'%s' property has value '%" PRIu32
"', which exceeds"
430 "the number of numa nodes: %d", VIRTIO_MEM_NODE_PROP
,
431 vmem
->node
, nb_numa_nodes
? nb_numa_nodes
: 1);
436 error_setg(errp
, "Incompatible with mlock");
440 rb
= vmem
->memdev
->mr
.ram_block
;
441 page_size
= qemu_ram_pagesize(rb
);
443 if (vmem
->block_size
< page_size
) {
444 error_setg(errp
, "'%s' property has to be at least the page size (0x%"
445 PRIx64
")", VIRTIO_MEM_BLOCK_SIZE_PROP
, page_size
);
447 } else if (!QEMU_IS_ALIGNED(vmem
->requested_size
, vmem
->block_size
)) {
448 error_setg(errp
, "'%s' property has to be multiples of '%s' (0x%" PRIx64
449 ")", VIRTIO_MEM_REQUESTED_SIZE_PROP
,
450 VIRTIO_MEM_BLOCK_SIZE_PROP
, vmem
->block_size
);
452 } else if (!QEMU_IS_ALIGNED(memory_region_size(&vmem
->memdev
->mr
),
454 error_setg(errp
, "'%s' property memdev size has to be multiples of"
455 "'%s' (0x%" PRIx64
")", VIRTIO_MEM_MEMDEV_PROP
,
456 VIRTIO_MEM_BLOCK_SIZE_PROP
, vmem
->block_size
);
460 if (ram_block_discard_require(true)) {
461 error_setg(errp
, "Discarding RAM is disabled");
465 ret
= ram_block_discard_range(rb
, 0, qemu_ram_get_used_length(rb
));
467 error_setg_errno(errp
, -ret
, "Unexpected error discarding RAM");
468 ram_block_discard_require(false);
472 virtio_mem_resize_usable_region(vmem
, vmem
->requested_size
, true);
474 vmem
->bitmap_size
= memory_region_size(&vmem
->memdev
->mr
) /
476 vmem
->bitmap
= bitmap_new(vmem
->bitmap_size
);
478 virtio_init(vdev
, TYPE_VIRTIO_MEM
, VIRTIO_ID_MEM
,
479 sizeof(struct virtio_mem_config
));
480 vmem
->vq
= virtio_add_queue(vdev
, 128, virtio_mem_handle_request
);
482 host_memory_backend_set_mapped(vmem
->memdev
, true);
483 vmstate_register_ram(&vmem
->memdev
->mr
, DEVICE(vmem
));
484 qemu_register_reset(virtio_mem_system_reset
, vmem
);
485 precopy_add_notifier(&vmem
->precopy_notifier
);
488 static void virtio_mem_device_unrealize(DeviceState
*dev
)
490 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
491 VirtIOMEM
*vmem
= VIRTIO_MEM(dev
);
493 precopy_remove_notifier(&vmem
->precopy_notifier
);
494 qemu_unregister_reset(virtio_mem_system_reset
, vmem
);
495 vmstate_unregister_ram(&vmem
->memdev
->mr
, DEVICE(vmem
));
496 host_memory_backend_set_mapped(vmem
->memdev
, false);
497 virtio_del_queue(vdev
, 0);
498 virtio_cleanup(vdev
);
499 g_free(vmem
->bitmap
);
500 ram_block_discard_require(false);
503 static int virtio_mem_restore_unplugged(VirtIOMEM
*vmem
)
505 RAMBlock
*rb
= vmem
->memdev
->mr
.ram_block
;
506 unsigned long first_zero_bit
, last_zero_bit
;
507 uint64_t offset
, length
;
510 /* Find consecutive unplugged blocks and discard the consecutive range. */
511 first_zero_bit
= find_first_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
);
512 while (first_zero_bit
< vmem
->bitmap_size
) {
513 offset
= first_zero_bit
* vmem
->block_size
;
514 last_zero_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
,
515 first_zero_bit
+ 1) - 1;
516 length
= (last_zero_bit
- first_zero_bit
+ 1) * vmem
->block_size
;
518 ret
= ram_block_discard_range(rb
, offset
, length
);
520 error_report("Unexpected error discarding RAM: %s",
524 first_zero_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
,
530 static int virtio_mem_post_load(void *opaque
, int version_id
)
532 if (migration_in_incoming_postcopy()) {
536 return virtio_mem_restore_unplugged(VIRTIO_MEM(opaque
));
539 typedef struct VirtIOMEMMigSanityChecks
{
542 uint64_t region_size
;
545 } VirtIOMEMMigSanityChecks
;
547 static int virtio_mem_mig_sanity_checks_pre_save(void *opaque
)
549 VirtIOMEMMigSanityChecks
*tmp
= opaque
;
550 VirtIOMEM
*vmem
= tmp
->parent
;
552 tmp
->addr
= vmem
->addr
;
553 tmp
->region_size
= memory_region_size(&vmem
->memdev
->mr
);
554 tmp
->block_size
= vmem
->block_size
;
555 tmp
->node
= vmem
->node
;
559 static int virtio_mem_mig_sanity_checks_post_load(void *opaque
, int version_id
)
561 VirtIOMEMMigSanityChecks
*tmp
= opaque
;
562 VirtIOMEM
*vmem
= tmp
->parent
;
563 const uint64_t new_region_size
= memory_region_size(&vmem
->memdev
->mr
);
565 if (tmp
->addr
!= vmem
->addr
) {
566 error_report("Property '%s' changed from 0x%" PRIx64
" to 0x%" PRIx64
,
567 VIRTIO_MEM_ADDR_PROP
, tmp
->addr
, vmem
->addr
);
571 * Note: Preparation for resizeable memory regions. The maximum size
572 * of the memory region must not change during migration.
574 if (tmp
->region_size
!= new_region_size
) {
575 error_report("Property '%s' size changed from 0x%" PRIx64
" to 0x%"
576 PRIx64
, VIRTIO_MEM_MEMDEV_PROP
, tmp
->region_size
,
580 if (tmp
->block_size
!= vmem
->block_size
) {
581 error_report("Property '%s' changed from 0x%" PRIx64
" to 0x%" PRIx64
,
582 VIRTIO_MEM_BLOCK_SIZE_PROP
, tmp
->block_size
,
586 if (tmp
->node
!= vmem
->node
) {
587 error_report("Property '%s' changed from %" PRIu32
" to %" PRIu32
,
588 VIRTIO_MEM_NODE_PROP
, tmp
->node
, vmem
->node
);
594 static const VMStateDescription vmstate_virtio_mem_sanity_checks
= {
595 .name
= "virtio-mem-device/sanity-checks",
596 .pre_save
= virtio_mem_mig_sanity_checks_pre_save
,
597 .post_load
= virtio_mem_mig_sanity_checks_post_load
,
598 .fields
= (VMStateField
[]) {
599 VMSTATE_UINT64(addr
, VirtIOMEMMigSanityChecks
),
600 VMSTATE_UINT64(region_size
, VirtIOMEMMigSanityChecks
),
601 VMSTATE_UINT64(block_size
, VirtIOMEMMigSanityChecks
),
602 VMSTATE_UINT32(node
, VirtIOMEMMigSanityChecks
),
603 VMSTATE_END_OF_LIST(),
607 static const VMStateDescription vmstate_virtio_mem_device
= {
608 .name
= "virtio-mem-device",
609 .minimum_version_id
= 1,
611 .post_load
= virtio_mem_post_load
,
612 .fields
= (VMStateField
[]) {
613 VMSTATE_WITH_TMP(VirtIOMEM
, VirtIOMEMMigSanityChecks
,
614 vmstate_virtio_mem_sanity_checks
),
615 VMSTATE_UINT64(usable_region_size
, VirtIOMEM
),
616 VMSTATE_UINT64(size
, VirtIOMEM
),
617 VMSTATE_UINT64(requested_size
, VirtIOMEM
),
618 VMSTATE_BITMAP(bitmap
, VirtIOMEM
, 0, bitmap_size
),
619 VMSTATE_END_OF_LIST()
623 static const VMStateDescription vmstate_virtio_mem
= {
624 .name
= "virtio-mem",
625 .minimum_version_id
= 1,
627 .fields
= (VMStateField
[]) {
628 VMSTATE_VIRTIO_DEVICE
,
629 VMSTATE_END_OF_LIST()
633 static void virtio_mem_fill_device_info(const VirtIOMEM
*vmem
,
634 VirtioMEMDeviceInfo
*vi
)
636 vi
->memaddr
= vmem
->addr
;
637 vi
->node
= vmem
->node
;
638 vi
->requested_size
= vmem
->requested_size
;
639 vi
->size
= vmem
->size
;
640 vi
->max_size
= memory_region_size(&vmem
->memdev
->mr
);
641 vi
->block_size
= vmem
->block_size
;
642 vi
->memdev
= object_get_canonical_path(OBJECT(vmem
->memdev
));
645 static MemoryRegion
*virtio_mem_get_memory_region(VirtIOMEM
*vmem
, Error
**errp
)
648 error_setg(errp
, "'%s' property must be set", VIRTIO_MEM_MEMDEV_PROP
);
652 return &vmem
->memdev
->mr
;
655 static void virtio_mem_add_size_change_notifier(VirtIOMEM
*vmem
,
658 notifier_list_add(&vmem
->size_change_notifiers
, notifier
);
661 static void virtio_mem_remove_size_change_notifier(VirtIOMEM
*vmem
,
664 notifier_remove(notifier
);
667 static void virtio_mem_get_size(Object
*obj
, Visitor
*v
, const char *name
,
668 void *opaque
, Error
**errp
)
670 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
671 uint64_t value
= vmem
->size
;
673 visit_type_size(v
, name
, &value
, errp
);
676 static void virtio_mem_get_requested_size(Object
*obj
, Visitor
*v
,
677 const char *name
, void *opaque
,
680 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
681 uint64_t value
= vmem
->requested_size
;
683 visit_type_size(v
, name
, &value
, errp
);
686 static void virtio_mem_set_requested_size(Object
*obj
, Visitor
*v
,
687 const char *name
, void *opaque
,
690 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
694 visit_type_size(v
, name
, &value
, &err
);
696 error_propagate(errp
, err
);
701 * The block size and memory backend are not fixed until the device was
702 * realized. realize() will verify these properties then.
704 if (DEVICE(obj
)->realized
) {
705 if (!QEMU_IS_ALIGNED(value
, vmem
->block_size
)) {
706 error_setg(errp
, "'%s' has to be multiples of '%s' (0x%" PRIx64
707 ")", name
, VIRTIO_MEM_BLOCK_SIZE_PROP
,
710 } else if (value
> memory_region_size(&vmem
->memdev
->mr
)) {
711 error_setg(errp
, "'%s' cannot exceed the memory backend size"
712 "(0x%" PRIx64
")", name
,
713 memory_region_size(&vmem
->memdev
->mr
));
717 if (value
!= vmem
->requested_size
) {
718 virtio_mem_resize_usable_region(vmem
, value
, false);
719 vmem
->requested_size
= value
;
722 * Trigger a config update so the guest gets notified. We trigger
723 * even if the size didn't change (especially helpful for debugging).
725 virtio_notify_config(VIRTIO_DEVICE(vmem
));
727 vmem
->requested_size
= value
;
731 static void virtio_mem_get_block_size(Object
*obj
, Visitor
*v
, const char *name
,
732 void *opaque
, Error
**errp
)
734 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
735 uint64_t value
= vmem
->block_size
;
737 visit_type_size(v
, name
, &value
, errp
);
740 static void virtio_mem_set_block_size(Object
*obj
, Visitor
*v
, const char *name
,
741 void *opaque
, Error
**errp
)
743 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
747 if (DEVICE(obj
)->realized
) {
748 error_setg(errp
, "'%s' cannot be changed", name
);
752 visit_type_size(v
, name
, &value
, &err
);
754 error_propagate(errp
, err
);
758 if (value
< VIRTIO_MEM_MIN_BLOCK_SIZE
) {
759 error_setg(errp
, "'%s' property has to be at least 0x%" PRIx32
, name
,
760 VIRTIO_MEM_MIN_BLOCK_SIZE
);
762 } else if (!is_power_of_2(value
)) {
763 error_setg(errp
, "'%s' property has to be a power of two", name
);
766 vmem
->block_size
= value
;
769 static void virtio_mem_precopy_exclude_unplugged(VirtIOMEM
*vmem
)
771 void * const host
= qemu_ram_get_host_addr(vmem
->memdev
->mr
.ram_block
);
772 unsigned long first_zero_bit
, last_zero_bit
;
773 uint64_t offset
, length
;
776 * Find consecutive unplugged blocks and exclude them from migration.
778 * Note: Blocks cannot get (un)plugged during precopy, no locking needed.
780 first_zero_bit
= find_first_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
);
781 while (first_zero_bit
< vmem
->bitmap_size
) {
782 offset
= first_zero_bit
* vmem
->block_size
;
783 last_zero_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
,
784 first_zero_bit
+ 1) - 1;
785 length
= (last_zero_bit
- first_zero_bit
+ 1) * vmem
->block_size
;
787 qemu_guest_free_page_hint(host
+ offset
, length
);
788 first_zero_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
,
793 static int virtio_mem_precopy_notify(NotifierWithReturn
*n
, void *data
)
795 VirtIOMEM
*vmem
= container_of(n
, VirtIOMEM
, precopy_notifier
);
796 PrecopyNotifyData
*pnd
= data
;
798 switch (pnd
->reason
) {
799 case PRECOPY_NOTIFY_SETUP
:
800 precopy_enable_free_page_optimization();
802 case PRECOPY_NOTIFY_AFTER_BITMAP_SYNC
:
803 virtio_mem_precopy_exclude_unplugged(vmem
);
812 static void virtio_mem_instance_init(Object
*obj
)
814 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
816 vmem
->block_size
= VIRTIO_MEM_MIN_BLOCK_SIZE
;
817 notifier_list_init(&vmem
->size_change_notifiers
);
818 vmem
->precopy_notifier
.notify
= virtio_mem_precopy_notify
;
820 object_property_add(obj
, VIRTIO_MEM_SIZE_PROP
, "size", virtio_mem_get_size
,
822 object_property_add(obj
, VIRTIO_MEM_REQUESTED_SIZE_PROP
, "size",
823 virtio_mem_get_requested_size
,
824 virtio_mem_set_requested_size
, NULL
, NULL
);
825 object_property_add(obj
, VIRTIO_MEM_BLOCK_SIZE_PROP
, "size",
826 virtio_mem_get_block_size
, virtio_mem_set_block_size
,
830 static Property virtio_mem_properties
[] = {
831 DEFINE_PROP_UINT64(VIRTIO_MEM_ADDR_PROP
, VirtIOMEM
, addr
, 0),
832 DEFINE_PROP_UINT32(VIRTIO_MEM_NODE_PROP
, VirtIOMEM
, node
, 0),
833 DEFINE_PROP_LINK(VIRTIO_MEM_MEMDEV_PROP
, VirtIOMEM
, memdev
,
834 TYPE_MEMORY_BACKEND
, HostMemoryBackend
*),
835 DEFINE_PROP_END_OF_LIST(),
838 static void virtio_mem_class_init(ObjectClass
*klass
, void *data
)
840 DeviceClass
*dc
= DEVICE_CLASS(klass
);
841 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
842 VirtIOMEMClass
*vmc
= VIRTIO_MEM_CLASS(klass
);
844 device_class_set_props(dc
, virtio_mem_properties
);
845 dc
->vmsd
= &vmstate_virtio_mem
;
847 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
848 vdc
->realize
= virtio_mem_device_realize
;
849 vdc
->unrealize
= virtio_mem_device_unrealize
;
850 vdc
->get_config
= virtio_mem_get_config
;
851 vdc
->get_features
= virtio_mem_get_features
;
852 vdc
->vmsd
= &vmstate_virtio_mem_device
;
854 vmc
->fill_device_info
= virtio_mem_fill_device_info
;
855 vmc
->get_memory_region
= virtio_mem_get_memory_region
;
856 vmc
->add_size_change_notifier
= virtio_mem_add_size_change_notifier
;
857 vmc
->remove_size_change_notifier
= virtio_mem_remove_size_change_notifier
;
860 static const TypeInfo virtio_mem_info
= {
861 .name
= TYPE_VIRTIO_MEM
,
862 .parent
= TYPE_VIRTIO_DEVICE
,
863 .instance_size
= sizeof(VirtIOMEM
),
864 .instance_init
= virtio_mem_instance_init
,
865 .class_init
= virtio_mem_class_init
,
866 .class_size
= sizeof(VirtIOMEMClass
),
869 static void virtio_register_types(void)
871 type_register_static(&virtio_mem_info
);
874 type_init(virtio_register_types
)