Skip to contentSkip to conversation

softmmu/memory_mapping: optimize dump/tpm for virtio-mem

PATCH Applied David Hildenbrand 3 participants 8 messages Jul 27, 2021 – Oct 4, 2021

lore
Share & tools
lore
#0 lore raw

v4 cover softmmu/memory_mapping: optimize dump/tpm for virtio-mem

Minor fixes and cleanups, followed by an optimization for virtio-mem regarding guest dumps and tpm.

virtio-mem logically plugs/unplugs memory within a sparse memory region and notifies via the RamDiscardMgr interface when parts become plugged (populated) or unplugged (discarded).

Currently, guest_phys_blocks_append() appends the whole (sparse) virtio-mem managed region and therefore tpm code might zero the hole region and dump code will dump the whole region. Let's only add logically plugged (populated) parts of that region, skipping over logically unplugged (discarded) parts by reusing the RamDiscardMgr infrastructure introduced to handle virtio-mem + VFIO properly.

v3 -> v4:
- "tpm: mark correct memory region range dirty when clearing RAM" -- Finally get it right :) I tried triggering that code without luck. So I ended up forcing that call path, verifying that the offset into memory regions is now correct.

v2 -> v3:
- "tpm: mark correct memory region range dirty when clearing RAM" -- Fix calculation of offset into memory region (thanks Peter!)
- "softmmu/memory_mapping: reuse qemu_get_guest_simple_memory_mapping()" -- Dropped

v1 -> v2:
- "softmmu/memory_mapping: factor out adding physical memory ranges" -- Simplify based on RamDiscardManager changes: add using a MemoryRegionSection
- "softmmu/memory_mapping: optimize for RamDiscardManager sections" -- Simplify based on RamDiscardManager changes

David Hildenbrand (4):
tpm: mark correct memory region range dirty when clearing RAM softmmu/memory_mapping: never merge ranges accross memory regions softmmu/memory_mapping: factor out adding physical memory ranges softmmu/memory_mapping: optimize for RamDiscardManager sections

 hw/tpm/tpm_ppi.c         |  5 +++-
 softmmu/memory_mapping.c | 64 ++++++++++++++++++++++++++--------------
 2 files changed, 46 insertions(+), 23 deletions(-)
Signature · 1 line
2.31.1
#1 lore raw

PATCH v4 1/4 tpm: mark correct memory region range dirty when clearing RAM

We might not start at the beginning of the memory region. Let's calculate the offset into the memory region via the difference in the host addresses.

Fixes ffab1be70692 ("tpm: clear RAM when "memory overwrite" requested")
Cc Marc-André Lureau <[email protected]>
Cc Paolo Bonzini <[email protected]>
Cc "Michael S. Tsirkin" <[email protected]>
Cc Eduardo Habkost <[email protected]>
Cc Alex Williamson <[email protected]>
Cc Dr. David Alan Gilbert <[email protected]>
Cc Igor Mammedov <[email protected]>
Cc Claudio Fontana <[email protected]>
Cc Thomas Huth <[email protected]>
Cc "Alex Bennée" <[email protected]>
Cc Peter Xu <[email protected]>
Cc Laurent Vivier <[email protected]>
Cc Stefan Berger <[email protected]>
---
 hw/tpm/tpm_ppi.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
hw/tpm/tpm_ppi.c +4 -1
index 362edcc5c9..274e9aa4b0 100644
@@ -30,11 +30,14 @@ void tpm_ppi_reset(TPMPPI *tpmppi)
         guest_phys_blocks_init(&guest_phys_blocks);
         guest_phys_blocks_append(&guest_phys_blocks);
         QTAILQ_FOREACH(block, &guest_phys_blocks.head, next) {
+            hwaddr mr_offs = block->host_addr -
+                             (uint8_t *)memory_region_get_ram_ptr(block->mr);
+
             trace_tpm_ppi_memset(block->host_addr,
                                  block->target_end - block->target_start);
             memset(block->host_addr, 0,
                    block->target_end - block->target_start);
-            memory_region_set_dirty(block->mr, 0,
+            memory_region_set_dirty(block->mr, mr_offs,
                                     block->target_end - block->target_start);
         }
         guest_phys_blocks_free(&guest_phys_blocks);
Signature · 1 line
2.31.1
Reviewed-by on v4 1/4
#2 lore raw

Re: [PATCH v4 1/4] tpm: mark correct memory region range dirty when clearing RAM

Quoted 4 lines · David Hildenbrand

We might not start at the beginning of the memory region. Let's calculate the offset into the memory region via the difference in the host addresses.

Quoted 16 lines
Fixes ffab1be70692 ("tpm: clear RAM when "memory overwrite" requested")
Cc Marc-André Lureau <[email protected]>
Cc Paolo Bonzini <[email protected]>
Cc "Michael S. Tsirkin" <[email protected]>
Cc Eduardo Habkost <[email protected]>
Cc Alex Williamson <[email protected]>
Cc Dr. David Alan Gilbert <[email protected]>
Cc Igor Mammedov <[email protected]>
Cc Claudio Fontana <[email protected]>
Cc Thomas Huth <[email protected]>
Cc "Alex Bennée" <[email protected]>
Cc Peter Xu <[email protected]>
Cc Laurent Vivier <[email protected]>
Cc Stefan Berger <[email protected]>
Signature · 1 line
Peter Xu
#3 lore raw

PATCH v4 2/4 softmmu/memory_mapping: never merge ranges accross memory regions

In reply to David Hildenbrand

Let's make sure to not merge when different memory regions are involved. Unlikely, but theoretically possible.

Cc Marc-André Lureau <[email protected]>
Cc Paolo Bonzini <[email protected]>
Cc "Michael S. Tsirkin" <[email protected]>
Cc Eduardo Habkost <[email protected]>
Cc Alex Williamson <[email protected]>
Cc Dr. David Alan Gilbert <[email protected]>
Cc Igor Mammedov <[email protected]>
Cc Claudio Fontana <[email protected]>
Cc Thomas Huth <[email protected]>
Cc "Alex Bennée" <[email protected]>
Cc Peter Xu <[email protected]>
Cc Laurent Vivier <[email protected]>
Cc Stefan Berger <[email protected]>
---
 softmmu/memory_mapping.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
softmmu/memory_mapping.c +2 -1
index e7af276546..d401ca7e31 100644
@@ -229,7 +229,8 @@ static void guest_phys_blocks_region_add(MemoryListener *listener,
 
         /* we want continuity in both guest-physical and host-virtual memory */
         if (predecessor->target_end < target_start ||
-            predecessor->host_addr + predecessor_size != host_addr) {
+            predecessor->host_addr + predecessor_size != host_addr ||
+            predecessor->mr != section->mr) {
             predecessor = NULL;
         }
     }
Signature · 1 line
2.31.1
#4 lore raw

PATCH v4 3/4 softmmu/memory_mapping: factor out adding physical memory ranges

In reply to David Hildenbrand

Let's factor out adding a MemoryRegionSection to the list, to be reused in RamDiscardManager context next.

Cc Marc-André Lureau <[email protected]>
Cc Paolo Bonzini <[email protected]>
Cc "Michael S. Tsirkin" <[email protected]>
Cc Eduardo Habkost <[email protected]>
Cc Alex Williamson <[email protected]>
Cc Dr. David Alan Gilbert <[email protected]>
Cc Igor Mammedov <[email protected]>
Cc Claudio Fontana <[email protected]>
Cc Thomas Huth <[email protected]>
Cc "Alex Bennée" <[email protected]>
Cc Peter Xu <[email protected]>
Cc Laurent Vivier <[email protected]>
Cc Stefan Berger <[email protected]>
---
 softmmu/memory_mapping.c | 41 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 21 deletions(-)
softmmu/memory_mapping.c +20 -21
index d401ca7e31..a2af02c41c 100644
@@ -193,29 +193,14 @@ typedef struct GuestPhysListener {
     MemoryListener listener;
 } GuestPhysListener;
 
-static void guest_phys_blocks_region_add(MemoryListener *listener,
+static void guest_phys_block_add_section(GuestPhysListener *g,
                                          MemoryRegionSection *section)
 {
-    GuestPhysListener *g;
-    uint64_t section_size;
-    hwaddr target_start, target_end;
-    uint8_t *host_addr;
-    GuestPhysBlock *predecessor;
-
-    /* we only care about RAM */
-    if (!memory_region_is_ram(section->mr) ||
-        memory_region_is_ram_device(section->mr) ||
-        memory_region_is_nonvolatile(section->mr)) {
-        return;
-    }
-
-    g            = container_of(listener, GuestPhysListener, listener);
-    section_size = int128_get64(section->size);
-    target_start = section->offset_within_address_space;
-    target_end   = target_start + section_size;
-    host_addr    = memory_region_get_ram_ptr(section->mr) +
-                   section->offset_within_region;
-    predecessor  = NULL;
+    const hwaddr target_start = section->offset_within_address_space;
+    const hwaddr target_end = target_start + int128_get64(section->size);
+    uint8_t *host_addr = memory_region_get_ram_ptr(section->mr) +
+                         section->offset_within_region;
+    GuestPhysBlock *predecessor = NULL;
 
     /* find continuity in guest physical address space */
     if (!QTAILQ_EMPTY(&g->list->head)) {
@@ -261,6 +246,20 @@ static void guest_phys_blocks_region_add(MemoryListener *listener,
 #endif
 }
 
+static void guest_phys_blocks_region_add(MemoryListener *listener,
+                                         MemoryRegionSection *section)
+{
+    GuestPhysListener *g = container_of(listener, GuestPhysListener, listener);
+
+    /* we only care about RAM */
+    if (!memory_region_is_ram(section->mr) ||
+        memory_region_is_ram_device(section->mr) ||
+        memory_region_is_nonvolatile(section->mr)) {
+        return;
+    }
+    guest_phys_block_add_section(g, section);
+}
+
 void guest_phys_blocks_append(GuestPhysBlockList *list)
 {
     GuestPhysListener g = { 0 };
Signature · 1 line
2.31.1
#5 lore raw

PATCH v4 4/4 softmmu/memory_mapping: optimize for RamDiscardManager sections

In reply to David Hildenbrand

virtio-mem logically plugs/unplugs memory within a sparse memory region and notifies via the RamDiscardManager interface when parts become plugged (populated) or unplugged (discarded).

Currently, we end up (via the two users)
1) zeroing all logically unplugged/discarded memory during TPM resets.
2) reading all logically unplugged/discarded memory when dumping, to figure out the content is zero.

1) is always bad, because we assume unplugged memory stays discarded (and is already implicitly zero).
2) isn't that bad with anonymous memory, we end up reading the zero page (slow and unnecessary, though). However, once we use some file-backed memory (future use case), even reading will populate memory.

Let's cut out all parts marked as not-populated (discarded) via the RamDiscardManager. As virtio-mem is the single user, this now means that logically unplugged memory ranges will no longer be included in the dump, which results in smaller dump files and faster dumping.

virtio-mem has a minimum granularity of 1 MiB (and the default is usually 2 MiB). Theoretically, we can see quite some fragmentation, in practice we won't have it completely fragmented in 1 MiB pieces. Still, we might end up with many physical ranges.

Both, the ELF format and kdump seem to be ready to support many individual ranges (e.g., for ELF it seems to be UINT32_MAX, kdump has a linear bitmap).

Cc Marc-André Lureau <[email protected]>
Cc Paolo Bonzini <[email protected]>
Cc "Michael S. Tsirkin" <[email protected]>
Cc Eduardo Habkost <[email protected]>
Cc Alex Williamson <[email protected]>
Cc Dr. David Alan Gilbert <[email protected]>
Cc Igor Mammedov <[email protected]>
Cc Claudio Fontana <[email protected]>
Cc Thomas Huth <[email protected]>
Cc "Alex Bennée" <[email protected]>
Cc Peter Xu <[email protected]>
Cc Laurent Vivier <[email protected]>
Cc Stefan Berger <[email protected]>
---
 softmmu/memory_mapping.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
softmmu/memory_mapping.c +20 -0
index a2af02c41c..a62eaa49cc 100644
@@ -246,6 +246,15 @@ static void guest_phys_block_add_section(GuestPhysListener *g,
 #endif
 }
 
+static int guest_phys_ram_populate_cb(MemoryRegionSection *section,
+                                      void *opaque)
+{
+    GuestPhysListener *g = opaque;
+
+    guest_phys_block_add_section(g, section);
+    return 0;
+}
+
 static void guest_phys_blocks_region_add(MemoryListener *listener,
                                          MemoryRegionSection *section)
 {
@@ -257,6 +266,17 @@ static void guest_phys_blocks_region_add(MemoryListener *listener,
         memory_region_is_nonvolatile(section->mr)) {
         return;
     }
+
+    /* for special sparse regions, only add populated parts */
+    if (memory_region_has_ram_discard_manager(section->mr)) {
+        RamDiscardManager *rdm;
+
+        rdm = memory_region_get_ram_discard_manager(section->mr);
+        ram_discard_manager_replay_populated(rdm, section,
+                                             guest_phys_ram_populate_cb, g);
+        return;
+    }
+
     guest_phys_block_add_section(g, section);
 }
 
Signature · 1 line
2.31.1
#6 lore raw
In reply to David Hildenbrand
Quoted 7 lines · David Hildenbrand

Minor fixes and cleanups, followed by an optimization for virtio-mem regarding guest dumps and tpm.

virtio-mem logically plugs/unplugs memory within a sparse memory region and notifies via the RamDiscardMgr interface when parts become plugged (populated) or unplugged (discarded).

Quoted 6 lines

Currently, guest_phys_blocks_append() appends the whole (sparse) virtio-mem managed region and therefore tpm code might zero the hole region and dump code will dump the whole region. Let's only add logically plugged (populated) parts of that region, skipping over logically unplugged (discarded) parts by reusing the RamDiscardMgr infrastructure introduced to handle virtio-mem + VFIO properly.

Queued, thanks.

Paolo

Quoted 29 lines

v3 -> v4:
- "tpm: mark correct memory region range dirty when clearing RAM" -- Finally get it right :) I tried triggering that code without luck. So I ended up forcing that call path, verifying that the offset into memory regions is now correct.

v2 -> v3:
- "tpm: mark correct memory region range dirty when clearing RAM" -- Fix calculation of offset into memory region (thanks Peter!)
- "softmmu/memory_mapping: reuse qemu_get_guest_simple_memory_mapping()" -- Dropped

v1 -> v2:
- "softmmu/memory_mapping: factor out adding physical memory ranges" -- Simplify based on RamDiscardManager changes: add using a MemoryRegionSection
- "softmmu/memory_mapping: optimize for RamDiscardManager sections" -- Simplify based on RamDiscardManager changes

David Hildenbrand (4):
tpm: mark correct memory region range dirty when clearing RAM softmmu/memory_mapping: never merge ranges accross memory regions softmmu/memory_mapping: factor out adding physical memory ranges softmmu/memory_mapping: optimize for RamDiscardManager sections

  hw/tpm/tpm_ppi.c         |  5 +++-
  softmmu/memory_mapping.c | 64 ++++++++++++++++++++++++++--------------
  2 files changed, 46 insertions(+), 23 deletions(-)
#7 lore raw
Quoted 8 lines · Paolo Bonzini
Quoted 7 lines · David Hildenbrand

Minor fixes and cleanups, followed by an optimization for virtio-mem regarding guest dumps and tpm.

virtio-mem logically plugs/unplugs memory within a sparse memory region and notifies via the RamDiscardMgr interface when parts become plugged (populated) or unplugged (discarded).

Quoted 9 lines
Quoted 6 lines

Currently, guest_phys_blocks_append() appends the whole (sparse) virtio-mem managed region and therefore tpm code might zero the hole region and dump code will dump the whole region. Let's only add logically plugged (populated) parts of that region, skipping over logically unplugged (discarded) parts by reusing the RamDiscardMgr infrastructure introduced to handle virtio-mem + VFIO properly.

Queued, thanks.

Thanks Paolo!

Signature · 3 lines
Thanks,

David / dhildenb