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 * We only had legacy x86 guests that did not support
37 * VIRTIO_MEM_F_UNPLUGGED_INACCESSIBLE. Other targets don't have legacy guests.
39 #if defined(TARGET_X86_64) || defined(TARGET_I386)
40 #define VIRTIO_MEM_HAS_LEGACY_GUESTS
44 * Let's not allow blocks smaller than 1 MiB, for example, to keep the tracking
47 #define VIRTIO_MEM_MIN_BLOCK_SIZE ((uint32_t)(1 * MiB))
49 static uint32_t virtio_mem_default_thp_size(void)
51 uint32_t default_thp_size
= VIRTIO_MEM_MIN_BLOCK_SIZE
;
53 #if defined(__x86_64__) || defined(__arm__) || defined(__powerpc64__)
54 default_thp_size
= 2 * MiB
;
55 #elif defined(__aarch64__)
56 if (qemu_real_host_page_size
== 4 * KiB
) {
57 default_thp_size
= 2 * MiB
;
58 } else if (qemu_real_host_page_size
== 16 * KiB
) {
59 default_thp_size
= 32 * MiB
;
60 } else if (qemu_real_host_page_size
== 64 * KiB
) {
61 default_thp_size
= 512 * MiB
;
65 return default_thp_size
;
69 * We want to have a reasonable default block size such that
70 * 1. We avoid splitting THPs when unplugging memory, which degrades
72 * 2. We avoid placing THPs for plugged blocks that also cover unplugged
75 * The actual THP size might differ between Linux kernels, so we try to probe
76 * it. In the future (if we ever run into issues regarding 2.), we might want
77 * to disable THP in case we fail to properly probe the THP size, or if the
78 * block size is configured smaller than the THP size.
80 static uint32_t thp_size
;
82 #define HPAGE_PMD_SIZE_PATH "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size"
83 static uint32_t virtio_mem_thp_size(void)
85 gchar
*content
= NULL
;
94 * Try to probe the actual THP size, fallback to (sane but eventually
95 * incorrect) default sizes.
97 if (g_file_get_contents(HPAGE_PMD_SIZE_PATH
, &content
, NULL
, NULL
) &&
98 !qemu_strtou64(content
, &endptr
, 0, &tmp
) &&
99 (!endptr
|| *endptr
== '\n')) {
100 /* Sanity-check the value and fallback to something reasonable. */
101 if (!tmp
|| !is_power_of_2(tmp
)) {
102 warn_report("Read unsupported THP size: %" PRIx64
, tmp
);
109 thp_size
= virtio_mem_default_thp_size();
110 warn_report("Could not detect THP size, falling back to %" PRIx64
111 " MiB.", thp_size
/ MiB
);
118 static uint64_t virtio_mem_default_block_size(RAMBlock
*rb
)
120 const uint64_t page_size
= qemu_ram_pagesize(rb
);
122 /* We can have hugetlbfs with a page size smaller than the THP size. */
123 if (page_size
== qemu_real_host_page_size
) {
124 return MAX(page_size
, virtio_mem_thp_size());
126 return MAX(page_size
, VIRTIO_MEM_MIN_BLOCK_SIZE
);
129 #if defined(VIRTIO_MEM_HAS_LEGACY_GUESTS)
130 static bool virtio_mem_has_shared_zeropage(RAMBlock
*rb
)
133 * We only have a guaranteed shared zeropage on ordinary MAP_PRIVATE
134 * anonymous RAM. In any other case, reading unplugged *can* populate a
135 * fresh page, consuming actual memory.
137 return !qemu_ram_is_shared(rb
) && rb
->fd
< 0 &&
138 qemu_ram_pagesize(rb
) == qemu_real_host_page_size
;
140 #endif /* VIRTIO_MEM_HAS_LEGACY_GUESTS */
143 * Size the usable region bigger than the requested size if possible. Esp.
144 * Linux guests will only add (aligned) memory blocks in case they fully
145 * fit into the usable region, but plug+online only a subset of the pages.
146 * The memory block size corresponds mostly to the section size.
148 * This allows e.g., to add 20MB with a section size of 128MB on x86_64, and
149 * a section size of 512MB on arm64 (as long as the start address is properly
150 * aligned, similar to ordinary DIMMs).
152 * We can change this at any time and maybe even make it configurable if
153 * necessary (as the section size can change). But it's more likely that the
154 * section size will rather get smaller and not bigger over time.
156 #if defined(TARGET_X86_64) || defined(TARGET_I386)
157 #define VIRTIO_MEM_USABLE_EXTENT (2 * (128 * MiB))
158 #elif defined(TARGET_ARM)
159 #define VIRTIO_MEM_USABLE_EXTENT (2 * (512 * MiB))
161 #error VIRTIO_MEM_USABLE_EXTENT not defined
164 static bool virtio_mem_is_busy(void)
167 * Postcopy cannot handle concurrent discards and we don't want to migrate
168 * pages on-demand with stale content when plugging new blocks.
170 * For precopy, we don't want unplugged blocks in our migration stream, and
171 * when plugging new blocks, the page content might differ between source
172 * and destination (observable by the guest when not initializing pages
173 * after plugging them) until we're running on the destination (as we didn't
174 * migrate these blocks when they were unplugged).
176 return migration_in_incoming_postcopy() || !migration_is_idle();
179 typedef int (*virtio_mem_range_cb
)(const VirtIOMEM
*vmem
, void *arg
,
180 uint64_t offset
, uint64_t size
);
182 static int virtio_mem_for_each_unplugged_range(const VirtIOMEM
*vmem
, void *arg
,
183 virtio_mem_range_cb cb
)
185 unsigned long first_zero_bit
, last_zero_bit
;
186 uint64_t offset
, size
;
189 first_zero_bit
= find_first_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
);
190 while (first_zero_bit
< vmem
->bitmap_size
) {
191 offset
= first_zero_bit
* vmem
->block_size
;
192 last_zero_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
,
193 first_zero_bit
+ 1) - 1;
194 size
= (last_zero_bit
- first_zero_bit
+ 1) * vmem
->block_size
;
196 ret
= cb(vmem
, arg
, offset
, size
);
200 first_zero_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
,
207 * Adjust the memory section to cover the intersection with the given range.
209 * Returns false if the intersection is empty, otherwise returns true.
211 static bool virito_mem_intersect_memory_section(MemoryRegionSection
*s
,
212 uint64_t offset
, uint64_t size
)
214 uint64_t start
= MAX(s
->offset_within_region
, offset
);
215 uint64_t end
= MIN(s
->offset_within_region
+ int128_get64(s
->size
),
222 s
->offset_within_address_space
+= start
- s
->offset_within_region
;
223 s
->offset_within_region
= start
;
224 s
->size
= int128_make64(end
- start
);
228 typedef int (*virtio_mem_section_cb
)(MemoryRegionSection
*s
, void *arg
);
230 static int virtio_mem_for_each_plugged_section(const VirtIOMEM
*vmem
,
231 MemoryRegionSection
*s
,
233 virtio_mem_section_cb cb
)
235 unsigned long first_bit
, last_bit
;
236 uint64_t offset
, size
;
239 first_bit
= s
->offset_within_region
/ vmem
->bitmap_size
;
240 first_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
, first_bit
);
241 while (first_bit
< vmem
->bitmap_size
) {
242 MemoryRegionSection tmp
= *s
;
244 offset
= first_bit
* vmem
->block_size
;
245 last_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
,
247 size
= (last_bit
- first_bit
+ 1) * vmem
->block_size
;
249 if (!virito_mem_intersect_memory_section(&tmp
, offset
, size
)) {
256 first_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
,
262 static int virtio_mem_for_each_unplugged_section(const VirtIOMEM
*vmem
,
263 MemoryRegionSection
*s
,
265 virtio_mem_section_cb cb
)
267 unsigned long first_bit
, last_bit
;
268 uint64_t offset
, size
;
271 first_bit
= s
->offset_within_region
/ vmem
->bitmap_size
;
272 first_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
, first_bit
);
273 while (first_bit
< vmem
->bitmap_size
) {
274 MemoryRegionSection tmp
= *s
;
276 offset
= first_bit
* vmem
->block_size
;
277 last_bit
= find_next_bit(vmem
->bitmap
, vmem
->bitmap_size
,
279 size
= (last_bit
- first_bit
+ 1) * vmem
->block_size
;
281 if (!virito_mem_intersect_memory_section(&tmp
, offset
, size
)) {
288 first_bit
= find_next_zero_bit(vmem
->bitmap
, vmem
->bitmap_size
,
294 static int virtio_mem_notify_populate_cb(MemoryRegionSection
*s
, void *arg
)
296 RamDiscardListener
*rdl
= arg
;
298 return rdl
->notify_populate(rdl
, s
);
301 static int virtio_mem_notify_discard_cb(MemoryRegionSection
*s
, void *arg
)
303 RamDiscardListener
*rdl
= arg
;
305 rdl
->notify_discard(rdl
, s
);
309 static void virtio_mem_notify_unplug(VirtIOMEM
*vmem
, uint64_t offset
,
312 RamDiscardListener
*rdl
;
314 QLIST_FOREACH(rdl
, &vmem
->rdl_list
, next
) {
315 MemoryRegionSection tmp
= *rdl
->section
;
317 if (!virito_mem_intersect_memory_section(&tmp
, offset
, size
)) {
320 rdl
->notify_discard(rdl
, &tmp
);
324 static int virtio_mem_notify_plug(VirtIOMEM
*vmem
, uint64_t offset
,
327 RamDiscardListener
*rdl
, *rdl2
;
330 QLIST_FOREACH(rdl
, &vmem
->rdl_list
, next
) {
331 MemoryRegionSection tmp
= *rdl
->section
;
333 if (!virito_mem_intersect_memory_section(&tmp
, offset
, size
)) {
336 ret
= rdl
->notify_populate(rdl
, &tmp
);
343 /* Notify all already-notified listeners. */
344 QLIST_FOREACH(rdl2
, &vmem
->rdl_list
, next
) {
345 MemoryRegionSection tmp
= *rdl
->section
;
350 if (!virito_mem_intersect_memory_section(&tmp
, offset
, size
)) {
353 rdl2
->notify_discard(rdl2
, &tmp
);
359 static void virtio_mem_notify_unplug_all(VirtIOMEM
*vmem
)
361 RamDiscardListener
*rdl
;
367 QLIST_FOREACH(rdl
, &vmem
->rdl_list
, next
) {
368 if (rdl
->double_discard_supported
) {
369 rdl
->notify_discard(rdl
, rdl
->section
);
371 virtio_mem_for_each_plugged_section(vmem
, rdl
->section
, rdl
,
372 virtio_mem_notify_discard_cb
);
377 static bool virtio_mem_test_bitmap(const VirtIOMEM
*vmem
, uint64_t start_gpa
,
378 uint64_t size
, bool plugged
)
380 const unsigned long first_bit
= (start_gpa
- vmem
->addr
) / vmem
->block_size
;
381 const unsigned long last_bit
= first_bit
+ (size
/ vmem
->block_size
) - 1;
382 unsigned long found_bit
;
384 /* We fake a shorter bitmap to avoid searching too far. */
386 found_bit
= find_next_zero_bit(vmem
->bitmap
, last_bit
+ 1, first_bit
);
388 found_bit
= find_next_bit(vmem
->bitmap
, last_bit
+ 1, first_bit
);
390 return found_bit
> last_bit
;
393 static void virtio_mem_set_bitmap(VirtIOMEM
*vmem
, uint64_t start_gpa
,
394 uint64_t size
, bool plugged
)
396 const unsigned long bit
= (start_gpa
- vmem
->addr
) / vmem
->block_size
;
397 const unsigned long nbits
= size
/ vmem
->block_size
;
400 bitmap_set(vmem
->bitmap
, bit
, nbits
);
402 bitmap_clear(vmem
->bitmap
, bit
, nbits
);
406 static void virtio_mem_send_response(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
407 struct virtio_mem_resp
*resp
)
409 VirtIODevice
*vdev
= VIRTIO_DEVICE(vmem
);
410 VirtQueue
*vq
= vmem
->vq
;
412 trace_virtio_mem_send_response(le16_to_cpu(resp
->type
));
413 iov_from_buf(elem
->in_sg
, elem
->in_num
, 0, resp
, sizeof(*resp
));
415 virtqueue_push(vq
, elem
, sizeof(*resp
));
416 virtio_notify(vdev
, vq
);
419 static void virtio_mem_send_response_simple(VirtIOMEM
*vmem
,
420 VirtQueueElement
*elem
,
423 struct virtio_mem_resp resp
= {
424 .type
= cpu_to_le16(type
),
427 virtio_mem_send_response(vmem
, elem
, &resp
);
430 static bool virtio_mem_valid_range(const VirtIOMEM
*vmem
, uint64_t gpa
,
433 if (!QEMU_IS_ALIGNED(gpa
, vmem
->block_size
)) {
436 if (gpa
+ size
< gpa
|| !size
) {
439 if (gpa
< vmem
->addr
|| gpa
>= vmem
->addr
+ vmem
->usable_region_size
) {
442 if (gpa
+ size
> vmem
->addr
+ vmem
->usable_region_size
) {
448 static int virtio_mem_set_block_state(VirtIOMEM
*vmem
, uint64_t start_gpa
,
449 uint64_t size
, bool plug
)
451 const uint64_t offset
= start_gpa
- vmem
->addr
;
452 RAMBlock
*rb
= vmem
->memdev
->mr
.ram_block
;
454 if (virtio_mem_is_busy()) {
459 if (ram_block_discard_range(rb
, offset
, size
)) {
462 virtio_mem_notify_unplug(vmem
, offset
, size
);
466 if (vmem
->prealloc
) {
467 void *area
= memory_region_get_ram_ptr(&vmem
->memdev
->mr
) + offset
;
468 int fd
= memory_region_get_fd(&vmem
->memdev
->mr
);
469 Error
*local_err
= NULL
;
471 os_mem_prealloc(fd
, area
, size
, 1, &local_err
);
476 * Warn only once, we don't want to fill the log with these
480 warn_report_err(local_err
);
483 error_free(local_err
);
489 ret
= virtio_mem_notify_plug(vmem
, offset
, size
);
493 /* Could be preallocation or a notifier populated memory. */
494 ram_block_discard_range(vmem
->memdev
->mr
.ram_block
, offset
, size
);
498 virtio_mem_set_bitmap(vmem
, start_gpa
, size
, plug
);
502 static int virtio_mem_state_change_request(VirtIOMEM
*vmem
, uint64_t gpa
,
503 uint16_t nb_blocks
, bool plug
)
505 const uint64_t size
= nb_blocks
* vmem
->block_size
;
508 if (!virtio_mem_valid_range(vmem
, gpa
, size
)) {
509 return VIRTIO_MEM_RESP_ERROR
;
512 if (plug
&& (vmem
->size
+ size
> vmem
->requested_size
)) {
513 return VIRTIO_MEM_RESP_NACK
;
516 /* test if really all blocks are in the opposite state */
517 if (!virtio_mem_test_bitmap(vmem
, gpa
, size
, !plug
)) {
518 return VIRTIO_MEM_RESP_ERROR
;
521 ret
= virtio_mem_set_block_state(vmem
, gpa
, size
, plug
);
523 return VIRTIO_MEM_RESP_BUSY
;
530 notifier_list_notify(&vmem
->size_change_notifiers
, &vmem
->size
);
531 return VIRTIO_MEM_RESP_ACK
;
534 static void virtio_mem_plug_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
535 struct virtio_mem_req
*req
)
537 const uint64_t gpa
= le64_to_cpu(req
->u
.plug
.addr
);
538 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.plug
.nb_blocks
);
541 trace_virtio_mem_plug_request(gpa
, nb_blocks
);
542 type
= virtio_mem_state_change_request(vmem
, gpa
, nb_blocks
, true);
543 virtio_mem_send_response_simple(vmem
, elem
, type
);
546 static void virtio_mem_unplug_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
547 struct virtio_mem_req
*req
)
549 const uint64_t gpa
= le64_to_cpu(req
->u
.unplug
.addr
);
550 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.unplug
.nb_blocks
);
553 trace_virtio_mem_unplug_request(gpa
, nb_blocks
);
554 type
= virtio_mem_state_change_request(vmem
, gpa
, nb_blocks
, false);
555 virtio_mem_send_response_simple(vmem
, elem
, type
);
558 static void virtio_mem_resize_usable_region(VirtIOMEM
*vmem
,
559 uint64_t requested_size
,
562 uint64_t newsize
= MIN(memory_region_size(&vmem
->memdev
->mr
),
563 requested_size
+ VIRTIO_MEM_USABLE_EXTENT
);
565 /* The usable region size always has to be multiples of the block size. */
566 newsize
= QEMU_ALIGN_UP(newsize
, vmem
->block_size
);
568 if (!requested_size
) {
572 if (newsize
< vmem
->usable_region_size
&& !can_shrink
) {
576 trace_virtio_mem_resized_usable_region(vmem
->usable_region_size
, newsize
);
577 vmem
->usable_region_size
= newsize
;
580 static int virtio_mem_unplug_all(VirtIOMEM
*vmem
)
582 RAMBlock
*rb
= vmem
->memdev
->mr
.ram_block
;
584 if (virtio_mem_is_busy()) {
588 if (ram_block_discard_range(rb
, 0, qemu_ram_get_used_length(rb
))) {
591 virtio_mem_notify_unplug_all(vmem
);
593 bitmap_clear(vmem
->bitmap
, 0, vmem
->bitmap_size
);
596 notifier_list_notify(&vmem
->size_change_notifiers
, &vmem
->size
);
598 trace_virtio_mem_unplugged_all();
599 virtio_mem_resize_usable_region(vmem
, vmem
->requested_size
, true);
603 static void virtio_mem_unplug_all_request(VirtIOMEM
*vmem
,
604 VirtQueueElement
*elem
)
606 trace_virtio_mem_unplug_all_request();
607 if (virtio_mem_unplug_all(vmem
)) {
608 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_BUSY
);
610 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_ACK
);
614 static void virtio_mem_state_request(VirtIOMEM
*vmem
, VirtQueueElement
*elem
,
615 struct virtio_mem_req
*req
)
617 const uint16_t nb_blocks
= le16_to_cpu(req
->u
.state
.nb_blocks
);
618 const uint64_t gpa
= le64_to_cpu(req
->u
.state
.addr
);
619 const uint64_t size
= nb_blocks
* vmem
->block_size
;
620 struct virtio_mem_resp resp
= {
621 .type
= cpu_to_le16(VIRTIO_MEM_RESP_ACK
),
624 trace_virtio_mem_state_request(gpa
, nb_blocks
);
625 if (!virtio_mem_valid_range(vmem
, gpa
, size
)) {
626 virtio_mem_send_response_simple(vmem
, elem
, VIRTIO_MEM_RESP_ERROR
);
630 if (virtio_mem_test_bitmap(vmem
, gpa
, size
, true)) {
631 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_PLUGGED
);
632 } else if (virtio_mem_test_bitmap(vmem
, gpa
, size
, false)) {
633 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_UNPLUGGED
);
635 resp
.u
.state
.state
= cpu_to_le16(VIRTIO_MEM_STATE_MIXED
);
637 trace_virtio_mem_state_response(le16_to_cpu(resp
.u
.state
.state
));
638 virtio_mem_send_response(vmem
, elem
, &resp
);
641 static void virtio_mem_handle_request(VirtIODevice
*vdev
, VirtQueue
*vq
)
643 const int len
= sizeof(struct virtio_mem_req
);
644 VirtIOMEM
*vmem
= VIRTIO_MEM(vdev
);
645 VirtQueueElement
*elem
;
646 struct virtio_mem_req req
;
650 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
655 if (iov_to_buf(elem
->out_sg
, elem
->out_num
, 0, &req
, len
) < len
) {
656 virtio_error(vdev
, "virtio-mem protocol violation: invalid request"
658 virtqueue_detach_element(vq
, elem
, 0);
663 if (iov_size(elem
->in_sg
, elem
->in_num
) <
664 sizeof(struct virtio_mem_resp
)) {
665 virtio_error(vdev
, "virtio-mem protocol violation: not enough space"
666 " for response: %zu",
667 iov_size(elem
->in_sg
, elem
->in_num
));
668 virtqueue_detach_element(vq
, elem
, 0);
673 type
= le16_to_cpu(req
.type
);
675 case VIRTIO_MEM_REQ_PLUG
:
676 virtio_mem_plug_request(vmem
, elem
, &req
);
678 case VIRTIO_MEM_REQ_UNPLUG
:
679 virtio_mem_unplug_request(vmem
, elem
, &req
);
681 case VIRTIO_MEM_REQ_UNPLUG_ALL
:
682 virtio_mem_unplug_all_request(vmem
, elem
);
684 case VIRTIO_MEM_REQ_STATE
:
685 virtio_mem_state_request(vmem
, elem
, &req
);
688 virtio_error(vdev
, "virtio-mem protocol violation: unknown request"
690 virtqueue_detach_element(vq
, elem
, 0);
699 static void virtio_mem_get_config(VirtIODevice
*vdev
, uint8_t *config_data
)
701 VirtIOMEM
*vmem
= VIRTIO_MEM(vdev
);
702 struct virtio_mem_config
*config
= (void *) config_data
;
704 config
->block_size
= cpu_to_le64(vmem
->block_size
);
705 config
->node_id
= cpu_to_le16(vmem
->node
);
706 config
->requested_size
= cpu_to_le64(vmem
->requested_size
);
707 config
->plugged_size
= cpu_to_le64(vmem
->size
);
708 config
->addr
= cpu_to_le64(vmem
->addr
);
709 config
->region_size
= cpu_to_le64(memory_region_size(&vmem
->memdev
->mr
));
710 config
->usable_region_size
= cpu_to_le64(vmem
->usable_region_size
);
713 static uint64_t virtio_mem_get_features(VirtIODevice
*vdev
, uint64_t features
,
716 MachineState
*ms
= MACHINE(qdev_get_machine());
717 VirtIOMEM
*vmem
= VIRTIO_MEM(vdev
);
719 if (ms
->numa_state
) {
720 #if defined(CONFIG_ACPI)
721 virtio_add_feature(&features
, VIRTIO_MEM_F_ACPI_PXM
);
724 assert(vmem
->unplugged_inaccessible
!= ON_OFF_AUTO_AUTO
);
725 if (vmem
->unplugged_inaccessible
== ON_OFF_AUTO_ON
) {
726 virtio_add_feature(&features
, VIRTIO_MEM_F_UNPLUGGED_INACCESSIBLE
);
731 static int virtio_mem_validate_features(VirtIODevice
*vdev
)
733 if (virtio_host_has_feature(vdev
, VIRTIO_MEM_F_UNPLUGGED_INACCESSIBLE
) &&
734 !virtio_vdev_has_feature(vdev
, VIRTIO_MEM_F_UNPLUGGED_INACCESSIBLE
)) {
740 static void virtio_mem_system_reset(void *opaque
)
742 VirtIOMEM
*vmem
= VIRTIO_MEM(opaque
);
745 * During usual resets, we will unplug all memory and shrink the usable
746 * region size. This is, however, not possible in all scenarios. Then,
747 * the guest has to deal with this manually (VIRTIO_MEM_REQ_UNPLUG_ALL).
749 virtio_mem_unplug_all(vmem
);
752 static void virtio_mem_device_realize(DeviceState
*dev
, Error
**errp
)
754 MachineState
*ms
= MACHINE(qdev_get_machine());
755 int nb_numa_nodes
= ms
->numa_state
? ms
->numa_state
->num_nodes
: 0;
756 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
757 VirtIOMEM
*vmem
= VIRTIO_MEM(dev
);
763 error_setg(errp
, "'%s' property is not set", VIRTIO_MEM_MEMDEV_PROP
);
765 } else if (host_memory_backend_is_mapped(vmem
->memdev
)) {
766 error_setg(errp
, "'%s' property specifies a busy memdev: %s",
767 VIRTIO_MEM_MEMDEV_PROP
,
768 object_get_canonical_path_component(OBJECT(vmem
->memdev
)));
770 } else if (!memory_region_is_ram(&vmem
->memdev
->mr
) ||
771 memory_region_is_rom(&vmem
->memdev
->mr
) ||
772 !vmem
->memdev
->mr
.ram_block
) {
773 error_setg(errp
, "'%s' property specifies an unsupported memdev",
774 VIRTIO_MEM_MEMDEV_PROP
);
778 if ((nb_numa_nodes
&& vmem
->node
>= nb_numa_nodes
) ||
779 (!nb_numa_nodes
&& vmem
->node
)) {
780 error_setg(errp
, "'%s' property has value '%" PRIu32
"', which exceeds"
781 "the number of numa nodes: %d", VIRTIO_MEM_NODE_PROP
,
782 vmem
->node
, nb_numa_nodes
? nb_numa_nodes
: 1);
787 error_setg(errp
, "Incompatible with mlock");
791 rb
= vmem
->memdev
->mr
.ram_block
;
792 page_size
= qemu_ram_pagesize(rb
);
794 #if defined(VIRTIO_MEM_HAS_LEGACY_GUESTS)
795 switch (vmem
->unplugged_inaccessible
) {
796 case ON_OFF_AUTO_AUTO
:
797 if (virtio_mem_has_shared_zeropage(rb
)) {
798 vmem
->unplugged_inaccessible
= ON_OFF_AUTO_OFF
;
800 vmem
->unplugged_inaccessible
= ON_OFF_AUTO_ON
;
803 case ON_OFF_AUTO_OFF
:
804 if (!virtio_mem_has_shared_zeropage(rb
)) {
805 warn_report("'%s' property set to 'off' with a memdev that does"
806 " not support the shared zeropage.",
807 VIRTIO_MEM_UNPLUGGED_INACCESSIBLE_PROP
);
813 #else /* VIRTIO_MEM_HAS_LEGACY_GUESTS */
814 vmem
->unplugged_inaccessible
= ON_OFF_AUTO_ON
;
815 #endif /* VIRTIO_MEM_HAS_LEGACY_GUESTS */
818 * If the block size wasn't configured by the user, use a sane default. This
819 * allows using hugetlbfs backends of any page size without manual
822 if (!vmem
->block_size
) {
823 vmem
->block_size
= virtio_mem_default_block_size(rb
);
826 if (vmem
->block_size
< page_size
) {
827 error_setg(errp
, "'%s' property has to be at least the page size (0x%"
828 PRIx64
")", VIRTIO_MEM_BLOCK_SIZE_PROP
, page_size
);
830 } else if (vmem
->block_size
< virtio_mem_default_block_size(rb
)) {
831 warn_report("'%s' property is smaller than the default block size (%"
832 PRIx64
" MiB)", VIRTIO_MEM_BLOCK_SIZE_PROP
,
833 virtio_mem_default_block_size(rb
) / MiB
);
835 if (!QEMU_IS_ALIGNED(vmem
->requested_size
, vmem
->block_size
)) {
836 error_setg(errp
, "'%s' property has to be multiples of '%s' (0x%" PRIx64
837 ")", VIRTIO_MEM_REQUESTED_SIZE_PROP
,
838 VIRTIO_MEM_BLOCK_SIZE_PROP
, vmem
->block_size
);
840 } else if (!QEMU_IS_ALIGNED(vmem
->addr
, vmem
->block_size
)) {
841 error_setg(errp
, "'%s' property has to be multiples of '%s' (0x%" PRIx64
842 ")", VIRTIO_MEM_ADDR_PROP
, VIRTIO_MEM_BLOCK_SIZE_PROP
,
845 } else if (!QEMU_IS_ALIGNED(memory_region_size(&vmem
->memdev
->mr
),
847 error_setg(errp
, "'%s' property memdev size has to be multiples of"
848 "'%s' (0x%" PRIx64
")", VIRTIO_MEM_MEMDEV_PROP
,
849 VIRTIO_MEM_BLOCK_SIZE_PROP
, vmem
->block_size
);
853 if (ram_block_coordinated_discard_require(true)) {
854 error_setg(errp
, "Discarding RAM is disabled");
858 ret
= ram_block_discard_range(rb
, 0, qemu_ram_get_used_length(rb
));
860 error_setg_errno(errp
, -ret
, "Unexpected error discarding RAM");
861 ram_block_coordinated_discard_require(false);
865 virtio_mem_resize_usable_region(vmem
, vmem
->requested_size
, true);
867 vmem
->bitmap_size
= memory_region_size(&vmem
->memdev
->mr
) /
869 vmem
->bitmap
= bitmap_new(vmem
->bitmap_size
);
871 virtio_init(vdev
, TYPE_VIRTIO_MEM
, VIRTIO_ID_MEM
,
872 sizeof(struct virtio_mem_config
));
873 vmem
->vq
= virtio_add_queue(vdev
, 128, virtio_mem_handle_request
);
875 host_memory_backend_set_mapped(vmem
->memdev
, true);
876 vmstate_register_ram(&vmem
->memdev
->mr
, DEVICE(vmem
));
877 qemu_register_reset(virtio_mem_system_reset
, vmem
);
880 * Set ourselves as RamDiscardManager before the plug handler maps the
881 * memory region and exposes it via an address space.
883 memory_region_set_ram_discard_manager(&vmem
->memdev
->mr
,
884 RAM_DISCARD_MANAGER(vmem
));
887 static void virtio_mem_device_unrealize(DeviceState
*dev
)
889 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
890 VirtIOMEM
*vmem
= VIRTIO_MEM(dev
);
893 * The unplug handler unmapped the memory region, it cannot be
894 * found via an address space anymore. Unset ourselves.
896 memory_region_set_ram_discard_manager(&vmem
->memdev
->mr
, NULL
);
897 qemu_unregister_reset(virtio_mem_system_reset
, vmem
);
898 vmstate_unregister_ram(&vmem
->memdev
->mr
, DEVICE(vmem
));
899 host_memory_backend_set_mapped(vmem
->memdev
, false);
900 virtio_del_queue(vdev
, 0);
901 virtio_cleanup(vdev
);
902 g_free(vmem
->bitmap
);
903 ram_block_coordinated_discard_require(false);
906 static int virtio_mem_discard_range_cb(const VirtIOMEM
*vmem
, void *arg
,
907 uint64_t offset
, uint64_t size
)
909 RAMBlock
*rb
= vmem
->memdev
->mr
.ram_block
;
911 return ram_block_discard_range(rb
, offset
, size
) ? -EINVAL
: 0;
914 static int virtio_mem_restore_unplugged(VirtIOMEM
*vmem
)
916 /* Make sure all memory is really discarded after migration. */
917 return virtio_mem_for_each_unplugged_range(vmem
, NULL
,
918 virtio_mem_discard_range_cb
);
921 static int virtio_mem_post_load(void *opaque
, int version_id
)
923 VirtIOMEM
*vmem
= VIRTIO_MEM(opaque
);
924 RamDiscardListener
*rdl
;
928 * We started out with all memory discarded and our memory region is mapped
929 * into an address space. Replay, now that we updated the bitmap.
931 QLIST_FOREACH(rdl
, &vmem
->rdl_list
, next
) {
932 ret
= virtio_mem_for_each_plugged_section(vmem
, rdl
->section
, rdl
,
933 virtio_mem_notify_populate_cb
);
939 if (migration_in_incoming_postcopy()) {
943 return virtio_mem_restore_unplugged(vmem
);
946 typedef struct VirtIOMEMMigSanityChecks
{
949 uint64_t region_size
;
952 } VirtIOMEMMigSanityChecks
;
954 static int virtio_mem_mig_sanity_checks_pre_save(void *opaque
)
956 VirtIOMEMMigSanityChecks
*tmp
= opaque
;
957 VirtIOMEM
*vmem
= tmp
->parent
;
959 tmp
->addr
= vmem
->addr
;
960 tmp
->region_size
= memory_region_size(&vmem
->memdev
->mr
);
961 tmp
->block_size
= vmem
->block_size
;
962 tmp
->node
= vmem
->node
;
966 static int virtio_mem_mig_sanity_checks_post_load(void *opaque
, int version_id
)
968 VirtIOMEMMigSanityChecks
*tmp
= opaque
;
969 VirtIOMEM
*vmem
= tmp
->parent
;
970 const uint64_t new_region_size
= memory_region_size(&vmem
->memdev
->mr
);
972 if (tmp
->addr
!= vmem
->addr
) {
973 error_report("Property '%s' changed from 0x%" PRIx64
" to 0x%" PRIx64
,
974 VIRTIO_MEM_ADDR_PROP
, tmp
->addr
, vmem
->addr
);
978 * Note: Preparation for resizeable memory regions. The maximum size
979 * of the memory region must not change during migration.
981 if (tmp
->region_size
!= new_region_size
) {
982 error_report("Property '%s' size changed from 0x%" PRIx64
" to 0x%"
983 PRIx64
, VIRTIO_MEM_MEMDEV_PROP
, tmp
->region_size
,
987 if (tmp
->block_size
!= vmem
->block_size
) {
988 error_report("Property '%s' changed from 0x%" PRIx64
" to 0x%" PRIx64
,
989 VIRTIO_MEM_BLOCK_SIZE_PROP
, tmp
->block_size
,
993 if (tmp
->node
!= vmem
->node
) {
994 error_report("Property '%s' changed from %" PRIu32
" to %" PRIu32
,
995 VIRTIO_MEM_NODE_PROP
, tmp
->node
, vmem
->node
);
1001 static const VMStateDescription vmstate_virtio_mem_sanity_checks
= {
1002 .name
= "virtio-mem-device/sanity-checks",
1003 .pre_save
= virtio_mem_mig_sanity_checks_pre_save
,
1004 .post_load
= virtio_mem_mig_sanity_checks_post_load
,
1005 .fields
= (VMStateField
[]) {
1006 VMSTATE_UINT64(addr
, VirtIOMEMMigSanityChecks
),
1007 VMSTATE_UINT64(region_size
, VirtIOMEMMigSanityChecks
),
1008 VMSTATE_UINT64(block_size
, VirtIOMEMMigSanityChecks
),
1009 VMSTATE_UINT32(node
, VirtIOMEMMigSanityChecks
),
1010 VMSTATE_END_OF_LIST(),
1014 static const VMStateDescription vmstate_virtio_mem_device
= {
1015 .name
= "virtio-mem-device",
1016 .minimum_version_id
= 1,
1018 .priority
= MIG_PRI_VIRTIO_MEM
,
1019 .post_load
= virtio_mem_post_load
,
1020 .fields
= (VMStateField
[]) {
1021 VMSTATE_WITH_TMP(VirtIOMEM
, VirtIOMEMMigSanityChecks
,
1022 vmstate_virtio_mem_sanity_checks
),
1023 VMSTATE_UINT64(usable_region_size
, VirtIOMEM
),
1024 VMSTATE_UINT64(size
, VirtIOMEM
),
1025 VMSTATE_UINT64(requested_size
, VirtIOMEM
),
1026 VMSTATE_BITMAP(bitmap
, VirtIOMEM
, 0, bitmap_size
),
1027 VMSTATE_END_OF_LIST()
1031 static const VMStateDescription vmstate_virtio_mem
= {
1032 .name
= "virtio-mem",
1033 .minimum_version_id
= 1,
1035 .fields
= (VMStateField
[]) {
1036 VMSTATE_VIRTIO_DEVICE
,
1037 VMSTATE_END_OF_LIST()
1041 static void virtio_mem_fill_device_info(const VirtIOMEM
*vmem
,
1042 VirtioMEMDeviceInfo
*vi
)
1044 vi
->memaddr
= vmem
->addr
;
1045 vi
->node
= vmem
->node
;
1046 vi
->requested_size
= vmem
->requested_size
;
1047 vi
->size
= vmem
->size
;
1048 vi
->max_size
= memory_region_size(&vmem
->memdev
->mr
);
1049 vi
->block_size
= vmem
->block_size
;
1050 vi
->memdev
= object_get_canonical_path(OBJECT(vmem
->memdev
));
1053 static MemoryRegion
*virtio_mem_get_memory_region(VirtIOMEM
*vmem
, Error
**errp
)
1055 if (!vmem
->memdev
) {
1056 error_setg(errp
, "'%s' property must be set", VIRTIO_MEM_MEMDEV_PROP
);
1060 return &vmem
->memdev
->mr
;
1063 static void virtio_mem_add_size_change_notifier(VirtIOMEM
*vmem
,
1066 notifier_list_add(&vmem
->size_change_notifiers
, notifier
);
1069 static void virtio_mem_remove_size_change_notifier(VirtIOMEM
*vmem
,
1072 notifier_remove(notifier
);
1075 static void virtio_mem_get_size(Object
*obj
, Visitor
*v
, const char *name
,
1076 void *opaque
, Error
**errp
)
1078 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1079 uint64_t value
= vmem
->size
;
1081 visit_type_size(v
, name
, &value
, errp
);
1084 static void virtio_mem_get_requested_size(Object
*obj
, Visitor
*v
,
1085 const char *name
, void *opaque
,
1088 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1089 uint64_t value
= vmem
->requested_size
;
1091 visit_type_size(v
, name
, &value
, errp
);
1094 static void virtio_mem_set_requested_size(Object
*obj
, Visitor
*v
,
1095 const char *name
, void *opaque
,
1098 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1102 visit_type_size(v
, name
, &value
, &err
);
1104 error_propagate(errp
, err
);
1109 * The block size and memory backend are not fixed until the device was
1110 * realized. realize() will verify these properties then.
1112 if (DEVICE(obj
)->realized
) {
1113 if (!QEMU_IS_ALIGNED(value
, vmem
->block_size
)) {
1114 error_setg(errp
, "'%s' has to be multiples of '%s' (0x%" PRIx64
1115 ")", name
, VIRTIO_MEM_BLOCK_SIZE_PROP
,
1118 } else if (value
> memory_region_size(&vmem
->memdev
->mr
)) {
1119 error_setg(errp
, "'%s' cannot exceed the memory backend size"
1120 "(0x%" PRIx64
")", name
,
1121 memory_region_size(&vmem
->memdev
->mr
));
1125 if (value
!= vmem
->requested_size
) {
1126 virtio_mem_resize_usable_region(vmem
, value
, false);
1127 vmem
->requested_size
= value
;
1130 * Trigger a config update so the guest gets notified. We trigger
1131 * even if the size didn't change (especially helpful for debugging).
1133 virtio_notify_config(VIRTIO_DEVICE(vmem
));
1135 vmem
->requested_size
= value
;
1139 static void virtio_mem_get_block_size(Object
*obj
, Visitor
*v
, const char *name
,
1140 void *opaque
, Error
**errp
)
1142 const VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1143 uint64_t value
= vmem
->block_size
;
1146 * If not configured by the user (and we're not realized yet), use the
1147 * default block size we would use with the current memory backend.
1150 if (vmem
->memdev
&& memory_region_is_ram(&vmem
->memdev
->mr
)) {
1151 value
= virtio_mem_default_block_size(vmem
->memdev
->mr
.ram_block
);
1153 value
= virtio_mem_thp_size();
1157 visit_type_size(v
, name
, &value
, errp
);
1160 static void virtio_mem_set_block_size(Object
*obj
, Visitor
*v
, const char *name
,
1161 void *opaque
, Error
**errp
)
1163 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1167 if (DEVICE(obj
)->realized
) {
1168 error_setg(errp
, "'%s' cannot be changed", name
);
1172 visit_type_size(v
, name
, &value
, &err
);
1174 error_propagate(errp
, err
);
1178 if (value
< VIRTIO_MEM_MIN_BLOCK_SIZE
) {
1179 error_setg(errp
, "'%s' property has to be at least 0x%" PRIx32
, name
,
1180 VIRTIO_MEM_MIN_BLOCK_SIZE
);
1182 } else if (!is_power_of_2(value
)) {
1183 error_setg(errp
, "'%s' property has to be a power of two", name
);
1186 vmem
->block_size
= value
;
1189 static void virtio_mem_instance_init(Object
*obj
)
1191 VirtIOMEM
*vmem
= VIRTIO_MEM(obj
);
1193 notifier_list_init(&vmem
->size_change_notifiers
);
1194 QLIST_INIT(&vmem
->rdl_list
);
1196 object_property_add(obj
, VIRTIO_MEM_SIZE_PROP
, "size", virtio_mem_get_size
,
1198 object_property_add(obj
, VIRTIO_MEM_REQUESTED_SIZE_PROP
, "size",
1199 virtio_mem_get_requested_size
,
1200 virtio_mem_set_requested_size
, NULL
, NULL
);
1201 object_property_add(obj
, VIRTIO_MEM_BLOCK_SIZE_PROP
, "size",
1202 virtio_mem_get_block_size
, virtio_mem_set_block_size
,
1206 static Property virtio_mem_properties
[] = {
1207 DEFINE_PROP_UINT64(VIRTIO_MEM_ADDR_PROP
, VirtIOMEM
, addr
, 0),
1208 DEFINE_PROP_UINT32(VIRTIO_MEM_NODE_PROP
, VirtIOMEM
, node
, 0),
1209 DEFINE_PROP_BOOL(VIRTIO_MEM_PREALLOC_PROP
, VirtIOMEM
, prealloc
, false),
1210 DEFINE_PROP_LINK(VIRTIO_MEM_MEMDEV_PROP
, VirtIOMEM
, memdev
,
1211 TYPE_MEMORY_BACKEND
, HostMemoryBackend
*),
1212 #if defined(VIRTIO_MEM_HAS_LEGACY_GUESTS)
1213 DEFINE_PROP_ON_OFF_AUTO(VIRTIO_MEM_UNPLUGGED_INACCESSIBLE_PROP
, VirtIOMEM
,
1214 unplugged_inaccessible
, ON_OFF_AUTO_AUTO
),
1216 DEFINE_PROP_END_OF_LIST(),
1219 static uint64_t virtio_mem_rdm_get_min_granularity(const RamDiscardManager
*rdm
,
1220 const MemoryRegion
*mr
)
1222 const VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1224 g_assert(mr
== &vmem
->memdev
->mr
);
1225 return vmem
->block_size
;
1228 static bool virtio_mem_rdm_is_populated(const RamDiscardManager
*rdm
,
1229 const MemoryRegionSection
*s
)
1231 const VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1232 uint64_t start_gpa
= vmem
->addr
+ s
->offset_within_region
;
1233 uint64_t end_gpa
= start_gpa
+ int128_get64(s
->size
);
1235 g_assert(s
->mr
== &vmem
->memdev
->mr
);
1237 start_gpa
= QEMU_ALIGN_DOWN(start_gpa
, vmem
->block_size
);
1238 end_gpa
= QEMU_ALIGN_UP(end_gpa
, vmem
->block_size
);
1240 if (!virtio_mem_valid_range(vmem
, start_gpa
, end_gpa
- start_gpa
)) {
1244 return virtio_mem_test_bitmap(vmem
, start_gpa
, end_gpa
- start_gpa
, true);
1247 struct VirtIOMEMReplayData
{
1252 static int virtio_mem_rdm_replay_populated_cb(MemoryRegionSection
*s
, void *arg
)
1254 struct VirtIOMEMReplayData
*data
= arg
;
1256 return ((ReplayRamPopulate
)data
->fn
)(s
, data
->opaque
);
1259 static int virtio_mem_rdm_replay_populated(const RamDiscardManager
*rdm
,
1260 MemoryRegionSection
*s
,
1261 ReplayRamPopulate replay_fn
,
1264 const VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1265 struct VirtIOMEMReplayData data
= {
1270 g_assert(s
->mr
== &vmem
->memdev
->mr
);
1271 return virtio_mem_for_each_plugged_section(vmem
, s
, &data
,
1272 virtio_mem_rdm_replay_populated_cb
);
1275 static int virtio_mem_rdm_replay_discarded_cb(MemoryRegionSection
*s
,
1278 struct VirtIOMEMReplayData
*data
= arg
;
1280 ((ReplayRamDiscard
)data
->fn
)(s
, data
->opaque
);
1284 static void virtio_mem_rdm_replay_discarded(const RamDiscardManager
*rdm
,
1285 MemoryRegionSection
*s
,
1286 ReplayRamDiscard replay_fn
,
1289 const VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1290 struct VirtIOMEMReplayData data
= {
1295 g_assert(s
->mr
== &vmem
->memdev
->mr
);
1296 virtio_mem_for_each_unplugged_section(vmem
, s
, &data
,
1297 virtio_mem_rdm_replay_discarded_cb
);
1300 static void virtio_mem_rdm_register_listener(RamDiscardManager
*rdm
,
1301 RamDiscardListener
*rdl
,
1302 MemoryRegionSection
*s
)
1304 VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1307 g_assert(s
->mr
== &vmem
->memdev
->mr
);
1308 rdl
->section
= memory_region_section_new_copy(s
);
1310 QLIST_INSERT_HEAD(&vmem
->rdl_list
, rdl
, next
);
1311 ret
= virtio_mem_for_each_plugged_section(vmem
, rdl
->section
, rdl
,
1312 virtio_mem_notify_populate_cb
);
1314 error_report("%s: Replaying plugged ranges failed: %s", __func__
,
1319 static void virtio_mem_rdm_unregister_listener(RamDiscardManager
*rdm
,
1320 RamDiscardListener
*rdl
)
1322 VirtIOMEM
*vmem
= VIRTIO_MEM(rdm
);
1324 g_assert(rdl
->section
->mr
== &vmem
->memdev
->mr
);
1326 if (rdl
->double_discard_supported
) {
1327 rdl
->notify_discard(rdl
, rdl
->section
);
1329 virtio_mem_for_each_plugged_section(vmem
, rdl
->section
, rdl
,
1330 virtio_mem_notify_discard_cb
);
1334 memory_region_section_free_copy(rdl
->section
);
1335 rdl
->section
= NULL
;
1336 QLIST_REMOVE(rdl
, next
);
1339 static void virtio_mem_class_init(ObjectClass
*klass
, void *data
)
1341 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1342 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
1343 VirtIOMEMClass
*vmc
= VIRTIO_MEM_CLASS(klass
);
1344 RamDiscardManagerClass
*rdmc
= RAM_DISCARD_MANAGER_CLASS(klass
);
1346 device_class_set_props(dc
, virtio_mem_properties
);
1347 dc
->vmsd
= &vmstate_virtio_mem
;
1349 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1350 vdc
->realize
= virtio_mem_device_realize
;
1351 vdc
->unrealize
= virtio_mem_device_unrealize
;
1352 vdc
->get_config
= virtio_mem_get_config
;
1353 vdc
->get_features
= virtio_mem_get_features
;
1354 vdc
->validate_features
= virtio_mem_validate_features
;
1355 vdc
->vmsd
= &vmstate_virtio_mem_device
;
1357 vmc
->fill_device_info
= virtio_mem_fill_device_info
;
1358 vmc
->get_memory_region
= virtio_mem_get_memory_region
;
1359 vmc
->add_size_change_notifier
= virtio_mem_add_size_change_notifier
;
1360 vmc
->remove_size_change_notifier
= virtio_mem_remove_size_change_notifier
;
1362 rdmc
->get_min_granularity
= virtio_mem_rdm_get_min_granularity
;
1363 rdmc
->is_populated
= virtio_mem_rdm_is_populated
;
1364 rdmc
->replay_populated
= virtio_mem_rdm_replay_populated
;
1365 rdmc
->replay_discarded
= virtio_mem_rdm_replay_discarded
;
1366 rdmc
->register_listener
= virtio_mem_rdm_register_listener
;
1367 rdmc
->unregister_listener
= virtio_mem_rdm_unregister_listener
;
1370 static const TypeInfo virtio_mem_info
= {
1371 .name
= TYPE_VIRTIO_MEM
,
1372 .parent
= TYPE_VIRTIO_DEVICE
,
1373 .instance_size
= sizeof(VirtIOMEM
),
1374 .instance_init
= virtio_mem_instance_init
,
1375 .class_init
= virtio_mem_class_init
,
1376 .class_size
= sizeof(VirtIOMEMClass
),
1377 .interfaces
= (InterfaceInfo
[]) {
1378 { TYPE_RAM_DISCARD_MANAGER
},
1383 static void virtio_register_types(void)
1385 type_register_static(&virtio_mem_info
);
1388 type_init(virtio_register_types
)