From 30acf078fced0fac523d4773fe06983d4cfce64d Mon Sep 17 00:00:00 2001

From: David Gibson <dgibson@redhat.com>

Date: Thu, 16 Nov 2017 03:07:17 +0100

Subject: [PATCH 13/30] memory: Move AddressSpaceDispatch from AddressSpace to

 FlatView

RH-Author: David Gibson <dgibson@redhat.com>

Message-id: <20171116030732.8560-8-dgibson@redhat.com>

Patchwork-id: 77697

O-Subject: [PATCH 07/22] memory: Move AddressSpaceDispatch from AddressSpace to FlatView

Bugzilla: 1481593

RH-Acked-by: Thomas Huth <thuth@redhat.com>

RH-Acked-by: Paolo Bonzini <pbonzini@redhat.com>

RH-Acked-by: Eduardo Habkost <ehabkost@redhat.com>

RH-Acked-by: Laurent Vivier <lvivier@redhat.com>

From: Alexey Kardashevskiy <aik@ozlabs.ru>

As we are going to share FlatView's between AddressSpace's,

and AddressSpaceDispatch is a structure to perform quick lookup

in FlatView, this moves ASD to FlatView.

After previosly open coded ASD rendering, we can also remove

as->next_dispatch as the new FlatView pointer is stored

on a stack and set to an AS atomically.

flatview_destroy() is executed under RCU instead of

address_space_dispatch_free() now.

This makes mem_begin/mem_commit to work with ASD and mem_add with FV

as later on mem_add will be taking FV as an argument anyway.

This should cause no behavioural change.

Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>

Message-Id: <20170921085110.25598-5-aik@ozlabs.ru>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

(cherry picked from commit 66a6df1dc6d5b28cc3e65db0d71683fbdddc6b62)

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

Conflicts:

	exec.c

Conflicts because we applied d5e5fafd "exec: add page_mask for

flatview_do_translate" out of order downstream.

Signed-off-by: David Gibson <dgibson@redhat.com>

---

 exec.c                         | 41 +++++++++++------------------------------

 include/exec/memory-internal.h | 12 +++++++-----

 include/exec/memory.h          |  2 --

 memory.c                       | 31 ++++++++++++++++++++++++-------

 4 files changed, 42 insertions(+), 44 deletions(-)

diff --git a/exec.c b/exec.c

index 4fed7b7..3c0b4f8 100644

--- a/exec.c

+++ b/exec.c

@@ -188,8 +188,6 @@ typedef struct PhysPageMap {

 } PhysPageMap;

 struct AddressSpaceDispatch {

-    struct rcu_head rcu;

-

     MemoryRegionSection *mru_section;

     /* This is a multi-level map on the physical address space.

      * The bottom level has pointers to MemoryRegionSections.

@@ -493,7 +491,7 @@ static MemoryRegionSection address_space_do_translate(AddressSpace *as,

     }

     for (;;) {

-        AddressSpaceDispatch *d = atomic_rcu_read(&as->dispatch);

+        AddressSpaceDispatch *d = address_space_to_dispatch(as);

         section = address_space_translate_internal(d, addr, &addr, &plen, is_mmio);

         iommu_mr = memory_region_get_iommu(section->mr);

@@ -1233,7 +1231,7 @@ hwaddr memory_region_section_get_iotlb(CPUState *cpu,

     } else {

         AddressSpaceDispatch *d;

-        d = atomic_rcu_read(&section->address_space->dispatch);

+        d = address_space_to_dispatch(section->address_space);

         iotlb = section - d->map.sections;

         iotlb += xlat;

     }

@@ -1358,9 +1356,9 @@ static void register_multipage(AddressSpaceDispatch *d,

     phys_page_set(d, start_addr >> TARGET_PAGE_BITS, num_pages, section_index);

 }

-void mem_add(AddressSpace *as, MemoryRegionSection *section)

+void mem_add(AddressSpace *as, FlatView *fv, MemoryRegionSection *section)

 {

-    AddressSpaceDispatch *d = as->next_dispatch;

+    AddressSpaceDispatch *d = flatview_to_dispatch(fv);

     MemoryRegionSection now = *section, remain = *section;

     Int128 page_size = int128_make64(TARGET_PAGE_SIZE);

@@ -2683,7 +2681,7 @@ static void io_mem_init(void)

                           NULL, UINT64_MAX);

 }

-void mem_begin(AddressSpace *as)

+AddressSpaceDispatch *mem_begin(AddressSpace *as)

 {

     AddressSpaceDispatch *d = g_new0(AddressSpaceDispatch, 1);

     uint16_t n;

@@ -2699,26 +2697,19 @@ void mem_begin(AddressSpace *as)

     d->phys_map  = (PhysPageEntry) { .ptr = PHYS_MAP_NODE_NIL, .skip = 1 };

     d->as = as;

-    as->next_dispatch = d;

+

+    return d;

 }

-static void address_space_dispatch_free(AddressSpaceDispatch *d)

+void address_space_dispatch_free(AddressSpaceDispatch *d)

 {

     phys_sections_free(&d->map);

     g_free(d);

 }

-void mem_commit(AddressSpace *as)

+void mem_commit(AddressSpaceDispatch *d)

 {

-    AddressSpaceDispatch *cur = as->dispatch;

-    AddressSpaceDispatch *next = as->next_dispatch;

-

-    phys_page_compact_all(next, next->map.nodes_nb);

-

-    atomic_rcu_set(&as->dispatch, next);

-    if (cur) {

-        call_rcu(cur, address_space_dispatch_free, rcu);

-    }

+    phys_page_compact_all(d, d->map.nodes_nb);

 }

 static void tcg_commit(MemoryListener *listener)

@@ -2734,21 +2725,11 @@ static void tcg_commit(MemoryListener *listener)

      * We reload the dispatch pointer now because cpu_reloading_memory_map()

      * may have split the RCU critical section.

      */

-    d = atomic_rcu_read(&cpuas->as->dispatch);

+    d = address_space_to_dispatch(cpuas->as);

     atomic_rcu_set(&cpuas->memory_dispatch, d);

     tlb_flush(cpuas->cpu);

 }

-void address_space_destroy_dispatch(AddressSpace *as)

-{

-    AddressSpaceDispatch *d = as->dispatch;

-

-    atomic_rcu_set(&as->dispatch, NULL);

-    if (d) {

-        call_rcu(d, address_space_dispatch_free, rcu);

-    }

-}

-

 static void memory_map_init(void)

 {

     system_memory = g_malloc(sizeof(*system_memory));

diff --git a/include/exec/memory-internal.h b/include/exec/memory-internal.h

index 9abde2f..6e08eda 100644

--- a/include/exec/memory-internal.h

+++ b/include/exec/memory-internal.h

@@ -22,16 +22,18 @@

 #ifndef CONFIG_USER_ONLY

 typedef struct AddressSpaceDispatch AddressSpaceDispatch;

-void address_space_destroy_dispatch(AddressSpace *as);

-

 extern const MemoryRegionOps unassigned_mem_ops;

 bool memory_region_access_valid(MemoryRegion *mr, hwaddr addr,

                                 unsigned size, bool is_write);

-void mem_add(AddressSpace *as, MemoryRegionSection *section);

-void mem_begin(AddressSpace *as);

-void mem_commit(AddressSpace *as);

+void mem_add(AddressSpace *as, FlatView *fv, MemoryRegionSection *section);

+AddressSpaceDispatch *mem_begin(AddressSpace *as);

+void mem_commit(AddressSpaceDispatch *d);

+

+AddressSpaceDispatch *address_space_to_dispatch(AddressSpace *as);

+AddressSpaceDispatch *flatview_to_dispatch(FlatView *fv);

+void address_space_dispatch_free(AddressSpaceDispatch *d);

 #endif

 #endif

diff --git a/include/exec/memory.h b/include/exec/memory.h

index 9ee0f2e..8f26d63 100644

--- a/include/exec/memory.h

+++ b/include/exec/memory.h

@@ -326,8 +326,6 @@ struct AddressSpace {

     int ioeventfd_nb;

     struct MemoryRegionIoeventfd *ioeventfds;

-    struct AddressSpaceDispatch *dispatch;

-    struct AddressSpaceDispatch *next_dispatch;

     QTAILQ_HEAD(memory_listeners_as, MemoryListener) listeners;

     QTAILQ_ENTRY(AddressSpace) address_spaces_link;

 };

diff --git a/memory.c b/memory.c

index f51e499..41e2e67 100644

--- a/memory.c

+++ b/memory.c

@@ -229,6 +229,7 @@ struct FlatView {

     FlatRange *ranges;

     unsigned nr;

     unsigned nr_allocated;

+    struct AddressSpaceDispatch *dispatch;

 };

 typedef struct AddressSpaceOps AddressSpaceOps;

@@ -289,6 +290,9 @@ static void flatview_destroy(FlatView *view)

 {

     int i;

+    if (view->dispatch) {

+        address_space_dispatch_free(view->dispatch);

+    }

     for (i = 0; i < view->nr; i++) {

         memory_region_unref(view->ranges[i].mr);

     }

@@ -304,10 +308,25 @@ static bool flatview_ref(FlatView *view)

 static void flatview_unref(FlatView *view)

 {

     if (atomic_fetch_dec(&view->ref) == 1) {

-        flatview_destroy(view);

+        call_rcu(view, flatview_destroy, rcu);

     }

 }

+static FlatView *address_space_to_flatview(AddressSpace *as)

+{

+    return atomic_rcu_read(&as->current_map);

+}

+

+AddressSpaceDispatch *flatview_to_dispatch(FlatView *fv)

+{

+    return fv->dispatch;

+}

+

+AddressSpaceDispatch *address_space_to_dispatch(AddressSpace *as)

+{

+    return flatview_to_dispatch(address_space_to_flatview(as));

+}

+

 static bool can_merge(FlatRange *r1, FlatRange *r2)

 {

     return int128_eq(addrrange_end(r1->addr), r2->addr.start)

@@ -890,13 +909,13 @@ static void address_space_update_topology(AddressSpace *as)

     FlatView *new_view = generate_memory_topology(as->root);

     int i;

-    mem_begin(as);

+    new_view->dispatch = mem_begin(as);

     for (i = 0; i < new_view->nr; i++) {

         MemoryRegionSection mrs =

             section_from_flat_range(&new_view->ranges[i], as);

-        mem_add(as, &mrs);

+        mem_add(as, new_view, &mrs);

     }

-    mem_commit(as);

+    mem_commit(new_view->dispatch);

     if (!QTAILQ_EMPTY(&as->listeners)) {

         address_space_update_topology_pass(as, old_view, new_view, false);

@@ -905,7 +924,7 @@ static void address_space_update_topology(AddressSpace *as)

     /* Writes are protected by the BQL.  */

     atomic_rcu_set(&as->current_map, new_view);

-    call_rcu(old_view, flatview_unref, rcu);

+    flatview_unref(old_view);

     /* Note that all the old MemoryRegions are still alive up to this

      * point.  This relieves most MemoryListeners from the need to

@@ -2635,7 +2654,6 @@ void address_space_init(AddressSpace *as, MemoryRegion *root, const char *name)

     QTAILQ_INIT(&as->listeners);

     QTAILQ_INSERT_TAIL(&address_spaces, as, address_spaces_link);

     as->name = g_strdup(name ? name : "anonymous");

-    as->dispatch = NULL;

     memory_region_update_pending |= root->enabled;

     memory_region_transaction_commit();

 }

@@ -2644,7 +2662,6 @@ static void do_address_space_destroy(AddressSpace *as)

 {

     bool do_free = as->malloced;

-    address_space_destroy_dispatch(as);

     assert(QTAILQ_EMPTY(&as->listeners));

     flatview_unref(as->current_map);

-- 

1.8.3.1