Introduce a helper function within RamDiscardManager to efficiently
notify all registered RamDiscardListeners, including VFIO listeners
about the memory conversion events between shared and private in
guest_memfd. The existing VFIO listener can dynamically DMA map/unmap
the shared pages based on the conversion type:
- For conversions from shared to private, the VFIO system ensures the
discarding of shared mapping from the IOMMU.
- For conversions from private to shared, it triggers the population of
the shared mapping into the IOMMU.
Additionally, there could be some special conversion requests:
- When a conversion request is made for a page already in the desired
state (either private or shared), the helper simply returns success.
- For requests involving a range partially in the desired state, only
the necessary segments are converted, ensuring the entire range
complies with the request efficiently.
- In scenarios where a conversion request is declined by other systems,
such as a failure from VFIO during notify_populate(), the helper will
roll back the request, maintaining consistency.
Signed-off-by: Chenyi Qiang <chenyi.qi...@intel.com>
---
include/sysemu/guest-memfd-manager.h | 3 +
system/guest-memfd-manager.c | 141 +++++++++++++++++++++++++++
2 files changed, 144 insertions(+)
diff --git a/include/sysemu/guest-memfd-manager.h
b/include/sysemu/guest-memfd-manager.h
index ab8c2ba362..1cce4cde43 100644
--- a/include/sysemu/guest-memfd-manager.h
+++ b/include/sysemu/guest-memfd-manager.h
@@ -43,4 +43,7 @@ struct GuestMemfdManagerClass {
void (*realize)(Object *gmm, MemoryRegion *mr, uint64_t region_size);
};
+int guest_memfd_state_change(GuestMemfdManager *gmm, uint64_t offset, uint64_t
size,
+ bool shared_to_private);
+
#endif
diff --git a/system/guest-memfd-manager.c b/system/guest-memfd-manager.c
index 7b90f26859..deb43db90b 100644
--- a/system/guest-memfd-manager.c
+++ b/system/guest-memfd-manager.c
@@ -243,6 +243,147 @@ static void guest_memfd_rdm_replay_discarded(const
RamDiscardManager *rdm,
guest_memfd_rdm_replay_discarded_cb);
}
+static bool guest_memfd_is_valid_range(GuestMemfdManager *gmm,
+ uint64_t offset, uint64_t size)
+{
+ MemoryRegion *mr = gmm->mr;
+
+ g_assert(mr);
+
+ uint64_t region_size = memory_region_size(mr);
+ if (!QEMU_IS_ALIGNED(offset, gmm->block_size)) {
+ return false;
+ }
+ if (offset + size < offset || !size) {
+ return false;
+ }
+ if (offset >= region_size || offset + size > region_size) {
+ return false;
+ }
+ return true;
+}
+
+static void guest_memfd_notify_discard(GuestMemfdManager *gmm,
+ uint64_t offset, uint64_t size)
+{
+ RamDiscardListener *rdl;
+
+ QLIST_FOREACH(rdl, &gmm->rdl_list, next) {
+ MemoryRegionSection tmp = *rdl->section;
+
+ if (!guest_memfd_rdm_intersect_memory_section(&tmp, offset, size)) {
+ continue;
+ }
+
+ guest_memfd_for_each_populated_range(gmm, &tmp, rdl,
+ guest_memfd_notify_discard_cb);
+ }
+}
+
+
+static int guest_memfd_notify_populate(GuestMemfdManager *gmm,
+ uint64_t offset, uint64_t size)
+{
+ RamDiscardListener *rdl, *rdl2;
+ int ret = 0;
+
+ QLIST_FOREACH(rdl, &gmm->rdl_list, next) {
+ MemoryRegionSection tmp = *rdl->section;
+
+ if (!guest_memfd_rdm_intersect_memory_section(&tmp, offset, size)) {
+ continue;
+ }
+
+ ret = guest_memfd_for_each_discarded_range(gmm, &tmp, rdl,
+
guest_memfd_notify_populate_cb);
+ if (ret) {
+ break;
+ }
+ }
+
+ if (ret) {
+ /* Notify all already-notified listeners. */
+ QLIST_FOREACH(rdl2, &gmm->rdl_list, next) {
+ MemoryRegionSection tmp = *rdl2->section;
+
+ if (rdl2 == rdl) {
+ break;
+ }
+ if (!guest_memfd_rdm_intersect_memory_section(&tmp, offset, size))
{
+ continue;
+ }
+
+ guest_memfd_for_each_discarded_range(gmm, &tmp, rdl2,
+
guest_memfd_notify_discard_cb);
+ }
+ }
+ return ret;
+}
+
+static bool guest_memfd_is_range_populated(GuestMemfdManager *gmm,
+ uint64_t offset, uint64_t size)
+{
+ const unsigned long first_bit = offset / gmm->block_size;
+ const unsigned long last_bit = first_bit + (size / gmm->block_size) - 1;
+ unsigned long found_bit;
+
+ /* We fake a shorter bitmap to avoid searching too far. */
+ found_bit = find_next_bit(gmm->discard_bitmap, last_bit + 1, first_bit);
+ return found_bit > last_bit;
+}
+
+static bool guest_memfd_is_range_discarded(GuestMemfdManager *gmm,
+ uint64_t offset, uint64_t size)
+{
+ const unsigned long first_bit = offset / gmm->block_size;
+ const unsigned long last_bit = first_bit + (size / gmm->block_size) - 1;
+ unsigned long found_bit;
+
+ /* We fake a shorter bitmap to avoid searching too far. */
+ found_bit = find_next_zero_bit(gmm->discard_bitmap, last_bit + 1,
first_bit);
+ return found_bit > last_bit;
+}
+
+int guest_memfd_state_change(GuestMemfdManager *gmm, uint64_t offset, uint64_t
size,
+ bool shared_to_private)
+{
+ int ret = 0;
+
+ if (!guest_memfd_is_valid_range(gmm, offset, size)) {
+ error_report("%s, invalid range: offset 0x%lx, size 0x%lx",
+ __func__, offset, size);
+ return -1;
+ }
+
+ if ((shared_to_private && guest_memfd_is_range_discarded(gmm, offset,
size)) ||
+ (!shared_to_private && guest_memfd_is_range_populated(gmm, offset,
size))) {
+ return 0;
+ }
+
+ if (shared_to_private) {
+ guest_memfd_notify_discard(gmm, offset, size);
+ } else {
+ ret = guest_memfd_notify_populate(gmm, offset, size);
+ }
+
+ if (!ret) {
+ unsigned long first_bit = offset / gmm->block_size;
+ unsigned long nbits = size / gmm->block_size;
+
+ g_assert((first_bit + nbits) <= gmm->discard_bitmap_size);
+
+ if (shared_to_private) {
+ bitmap_set(gmm->discard_bitmap, first_bit, nbits);
+ } else {
+ bitmap_clear(gmm->discard_bitmap, first_bit, nbits);
+ }
+
+ return 0;
+ }
+
+ return ret;
+}
+
static void guest_memfd_manager_realize(Object *obj, MemoryRegion *mr,
uint64_t region_size)
{
--
2.43.5
