Commit eb7eeb88 authored by Paolo Bonzini's avatar Paolo Bonzini
Browse files

memory: split address_space_read and address_space_write 



Rather than dispatching on is_write for every iteration, make
address_space_rw call one of the two functions.  The amount of
duplicate logic is pretty small, and memory_access_is_direct can
be tweaked so that it inlines better in the callers.

Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
parent 612263cf

exec.c

+116 −92
Original line number Diff line number Diff line
@@ -392,11 +392,10 @@ address_space_translate_internal(AddressSpaceDispatch *d, hwaddr addr, hwaddr *x 


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

{

    if (memory_region_is_ram(mr)) {

        return !(is_write && mr->readonly);

    }

    if (memory_region_is_romd(mr)) {

        return !is_write;

    if (is_write) {

        return memory_region_is_ram(mr) && !mr->readonly;

    } else {

        return memory_region_is_ram(mr) || memory_region_is_romd(mr);

    }



    return false;
@@ -2469,8 +2468,8 @@ static bool prepare_mmio_access(MemoryRegion *mr) 
    return release_lock;

}



MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                             uint8_t *buf, int len, bool is_write)

MemTxResult address_space_write(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                                const uint8_t *buf, int len)

{

    hwaddr l;

    uint8_t *ptr;
@@ -2483,10 +2482,9 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, 
    rcu_read_lock();

    while (len > 0) {

        l = len;

        mr = address_space_translate(as, addr, &addr1, &l, is_write);

        mr = address_space_translate(as, addr, &addr1, &l, true);



        if (is_write) {

            if (!memory_access_is_direct(mr, is_write)) {

        if (!memory_access_is_direct(mr, true)) {

            release_lock |= prepare_mmio_access(mr);

            l = memory_access_size(mr, l, addr1);

            /* XXX: could force current_cpu to NULL to avoid
@@ -2526,8 +2524,38 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, 
            memcpy(ptr, buf, l);

            invalidate_and_set_dirty(mr, addr1, l);

        }

        } else {

            if (!memory_access_is_direct(mr, is_write)) {



        if (release_lock) {

            qemu_mutex_unlock_iothread();

            release_lock = false;

        }



        len -= l;

        buf += l;

        addr += l;

    }

    rcu_read_unlock();



    return result;

}



MemTxResult address_space_read(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                               uint8_t *buf, int len)

{

    hwaddr l;

    uint8_t *ptr;

    uint64_t val;

    hwaddr addr1;

    MemoryRegion *mr;

    MemTxResult result = MEMTX_OK;

    bool release_lock = false;



    rcu_read_lock();

    while (len > 0) {

        l = len;

        mr = address_space_translate(as, addr, &addr1, &l, false);



        if (!memory_access_is_direct(mr, false)) {

            /* I/O case */

            release_lock |= prepare_mmio_access(mr);

            l = memory_access_size(mr, l, addr1);
@@ -2564,7 +2592,6 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, 
            ptr = qemu_get_ram_ptr(mr->ram_addr + addr1);

            memcpy(buf, ptr, l);

        }

        }



        if (release_lock) {

            qemu_mutex_unlock_iothread();
@@ -2580,19 +2607,16 @@ MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs, 
    return result;

}



MemTxResult address_space_write(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                                const uint8_t *buf, int len)

MemTxResult address_space_rw(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                             uint8_t *buf, int len, bool is_write)

{

    return address_space_rw(as, addr, attrs, (uint8_t *)buf, len, true);

    if (is_write) {

        return address_space_write(as, addr, attrs, (uint8_t *)buf, len);

    } else {

        return address_space_read(as, addr, attrs, (uint8_t *)buf, len);

    }



MemTxResult address_space_read(AddressSpace *as, hwaddr addr, MemTxAttrs attrs,

                               uint8_t *buf, int len)

{

    return address_space_rw(as, addr, attrs, buf, len, false);

}





void cpu_physical_memory_rw(hwaddr addr, uint8_t *buf,

                            int len, int is_write)

{