From e85fa0f42359527628b5b2243c514acc9670871a Mon Sep 17 00:00:00 2001

From: Paolo Bonzini <pbonzini@redhat.com>

Date: Thu, 8 Mar 2018 15:58:16 +0100

Subject: [PATCH 03/17] address_space_read: address_space_to_flatview needs RCU

 lock

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

Message-id: <20180308155819.20598-4-pbonzini@redhat.com>

Patchwork-id: 79190

O-Subject: [RHEL7.5 qemu-kvm-rhev PATCH 3/6] address_space_read: address_space_to_flatview needs RCU lock

Bugzilla: 1554930

RH-Acked-by: Cornelia Huck <cohuck@redhat.com>

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

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

address_space_read is calling address_space_to_flatview but it can

be called outside the RCU lock.  To fix it, push the rcu_read_lock/unlock

pair up from flatview_read_full to address_space_read's constant size

fast path and address_space_read_full.

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

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

(cherry pick from commit b2a44fcad74f1cc7a6786d38eba7db12ab2352ba)

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

---

 exec.c                | 38 +++++++++++++++++++++++++-------------

 include/exec/memory.h | 23 +++++++++--------------

 2 files changed, 34 insertions(+), 27 deletions(-)

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

index 8b50133..43c66da 100644

--- a/exec.c

+++ b/exec.c

@@ -2512,6 +2512,8 @@ static const MemoryRegionOps watch_mem_ops = {

     .endianness = DEVICE_NATIVE_ENDIAN,

 };

+static MemTxResult flatview_read(FlatView *fv, hwaddr addr,

+                                      MemTxAttrs attrs, uint8_t *buf, int len);

 static MemTxResult flatview_write(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

                                   const uint8_t *buf, int len);

 static bool flatview_access_valid(FlatView *fv, hwaddr addr, int len,

@@ -3029,24 +3031,18 @@ MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,

     return result;

 }

-MemTxResult flatview_read_full(FlatView *fv, hwaddr addr,

-                               MemTxAttrs attrs, uint8_t *buf, int len)

+/* Called from RCU critical section.  */

+static MemTxResult flatview_read(FlatView *fv, hwaddr addr,

+                                 MemTxAttrs attrs, uint8_t *buf, int len)

 {

     hwaddr l;

     hwaddr addr1;

     MemoryRegion *mr;

-    MemTxResult result = MEMTX_OK;

-

-    if (len > 0) {

-        rcu_read_lock();

-        l = len;

-        mr = flatview_translate(fv, addr, &addr1, &l, false);

-        result = flatview_read_continue(fv, addr, attrs, buf, len,

-                                        addr1, l, mr);

-        rcu_read_unlock();

-    }

-    return result;

+    l = len;

+    mr = flatview_translate(fv, addr, &addr1, &l, false);

+    return flatview_read_continue(fv, addr, attrs, buf, len,

+                                  addr1, l, mr);

 }

 static MemTxResult flatview_rw(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

@@ -3067,6 +3063,22 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr,

                        addr, attrs, buf, len, is_write);

 }

+MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,

+                                    MemTxAttrs attrs, uint8_t *buf, int len)

+{

+    MemTxResult result = MEMTX_OK;

+    FlatView *fv;

+

+    if (len > 0) {

+        rcu_read_lock();

+        fv = address_space_to_flatview(as);

+        result = flatview_read(fv, addr, attrs, buf, len);

+        rcu_read_unlock();

+    }

+

+    return result;

+}

+

 MemTxResult address_space_write(AddressSpace *as, hwaddr addr,

                                 MemTxAttrs attrs,

                                 const uint8_t *buf, int len)

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

index 3df0dcc..a66b6ef 100644

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

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

@@ -1917,13 +1917,12 @@ void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len,

 /* Internal functions, part of the implementation of address_space_read.  */

+MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr,

+                                    MemTxAttrs attrs, uint8_t *buf, int len);

 MemTxResult flatview_read_continue(FlatView *fv, hwaddr addr,

                                    MemTxAttrs attrs, uint8_t *buf,

                                    int len, hwaddr addr1, hwaddr l,

                                    MemoryRegion *mr);

-

-MemTxResult flatview_read_full(FlatView *fv, hwaddr addr,

-                               MemTxAttrs attrs, uint8_t *buf, int len);

 void *qemu_map_ram_ptr(RAMBlock *ram_block, ram_addr_t addr);

 static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)

@@ -1942,7 +1941,7 @@ static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)

  *

  * Return a MemTxResult indicating whether the operation succeeded

  * or failed (eg unassigned memory, device rejected the transaction,

- * IOMMU fault).

+ * IOMMU fault).  Called within RCU critical section.

  *

  * @as: #AddressSpace to be accessed

  * @addr: address within that address space

@@ -1950,17 +1949,20 @@ static inline bool memory_access_is_direct(MemoryRegion *mr, bool is_write)

  * @buf: buffer with the data transferred

  */

 static inline __attribute__((__always_inline__))

-MemTxResult flatview_read(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

-                          uint8_t *buf, int len)

+MemTxResult address_space_read(AddressSpace *as, hwaddr addr,

+                               MemTxAttrs attrs, uint8_t *buf,

+                               int len)

 {

     MemTxResult result = MEMTX_OK;

     hwaddr l, addr1;

     void *ptr;

     MemoryRegion *mr;

+    FlatView *fv;

     if (__builtin_constant_p(len)) {

         if (len) {

             rcu_read_lock();

+            fv = address_space_to_flatview(as);

             l = len;

             mr = flatview_translate(fv, addr, &addr1, &l, false);

             if (len == l && memory_access_is_direct(mr, false)) {

@@ -1973,18 +1975,11 @@ MemTxResult flatview_read(FlatView *fv, hwaddr addr, MemTxAttrs attrs,

             rcu_read_unlock();

         }

     } else {

-        result = flatview_read_full(fv, addr, attrs, buf, len);

+        result = address_space_read_full(as, addr, attrs, buf, len);

     }

     return result;

 }

-static inline MemTxResult address_space_read(AddressSpace *as, hwaddr addr,

-                                             MemTxAttrs attrs, uint8_t *buf,

-                                             int len)

-{

-    return flatview_read(address_space_to_flatview(as), addr, attrs, buf, len);

-}

-

 /**

  * address_space_read_cached: read from a cached RAM region

  *

-- 

1.8.3.1