Commit c760cb77 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/dgilbert/tags/pull-migration-20191011a' into staging 



Migration pull 2019-10-11

Mostly cleanups and minor fixes

[Note I'm seeing a hang on the aarch64 hosted x86-64 tcg migration
test in xbzrle; but I'm seeing that on current head as well]

# gpg: Signature made Fri 11 Oct 2019 20:14:31 BST
# gpg:                using RSA key 45F5C71B4A0CB7FB977A9FA90516331EBC5BFDE7
# gpg: Good signature from "Dr. David Alan Gilbert (RH2) <dgilbert@redhat.com>" [full]
# Primary key fingerprint: 45F5 C71B 4A0C B7FB 977A  9FA9 0516 331E BC5B FDE7

* remotes/dgilbert/tags/pull-migration-20191011a: (21 commits)
  migration: Support gtree migration
  migration/multifd: pages->used would be cleared when attach to multifd_send_state
  migration/multifd: initialize packet->magic/version once at setup stage
  migration/multifd: use pages->allocated instead of the static max
  migration/multifd: fix a typo in comment of multifd_recv_unfill_packet()
  migration/postcopy: check PostcopyState before setting to POSTCOPY_INCOMING_RUNNING
  migration/postcopy: rename postcopy_ram_enable_notify to postcopy_ram_incoming_setup
  migration/postcopy: postpone setting PostcopyState to END
  migration/postcopy: mis->have_listen_thread check will never be touched
  migration: report SaveStateEntry id and name on failure
  migration: pass in_postcopy instead of check state again
  migration/postcopy: fix typo in mark_postcopy_blocktime_begin's comment
  migration/postcopy: map large zero page in postcopy_ram_incoming_setup()
  migration/postcopy: allocate tmp_page in setup stage
  migration: Don't try and recover return path in non-postcopy
  rcu: Use automatic rc_read unlock in core memory/exec code
  migration: Use automatic rcu_read unlock in rdma.c
  migration: Use automatic rcu_read unlock in ram.c
  migration: Fix missing rcu_read_unlock
  rcu: Add automatically released rcu_read_lock variants
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 22dbfdec 9a85e4b8

docs/devel/rcu.txt

+16 −0
Original line number Diff line number Diff line
@@ -187,6 +187,22 @@ The following APIs must be used before RCU is used in a thread: 
Note that these APIs are relatively heavyweight, and should _not_ be

nested.



Convenience macros

==================



Two macros are provided that automatically release the read lock at the

end of the scope.



      RCU_READ_LOCK_GUARD()



         Takes the lock and will release it at the end of the block it's

         used in.



      WITH_RCU_READ_LOCK_GUARD()  { code }



         Is used at the head of a block to protect the code within the block.



Note that 'goto'ing out of the guarded block will also drop the lock.



DIFFERENCES WITH LINUX

======================

exec.c

+48 −68
Original line number Diff line number Diff line
@@ -1037,16 +1037,14 @@ void tb_invalidate_phys_addr(AddressSpace *as, hwaddr addr, MemTxAttrs attrs) 
        return;

    }



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

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

    if (!(memory_region_is_ram(mr)

          || memory_region_is_romd(mr))) {

        rcu_read_unlock();

        return;

    }

    ram_addr = memory_region_get_ram_addr(mr) + addr;

    tb_invalidate_phys_page_range(ram_addr, ram_addr + 1);

    rcu_read_unlock();

}



static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
@@ -1332,14 +1330,13 @@ static void tlb_reset_dirty_range_all(ram_addr_t start, ram_addr_t length) 
    end = TARGET_PAGE_ALIGN(start + length);

    start &= TARGET_PAGE_MASK;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    block = qemu_get_ram_block(start);

    assert(block == qemu_get_ram_block(end - 1));

    start1 = (uintptr_t)ramblock_ptr(block, start - block->offset);

    CPU_FOREACH(cpu) {

        tlb_reset_dirty(cpu, start1, length);

    }

    rcu_read_unlock();

}



/* Note: start and end must be within the same ram block.  */
@@ -1360,8 +1357,7 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, 
    end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;

    page = start >> TARGET_PAGE_BITS;



    rcu_read_lock();



    WITH_RCU_READ_LOCK_GUARD() {

        blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);

        ramblock = qemu_get_ram_block(start);

        /* Range sanity check on the ramblock */
@@ -1371,7 +1367,8 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, 
        while (page < end) {

            unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE;

            unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE;

        unsigned long num = MIN(end - page, DIRTY_MEMORY_BLOCK_SIZE - offset);

            unsigned long num = MIN(end - page,

                                    DIRTY_MEMORY_BLOCK_SIZE - offset);



            dirty |= bitmap_test_and_clear_atomic(blocks->blocks[idx],

                                                  offset, num);
@@ -1381,8 +1378,7 @@ bool cpu_physical_memory_test_and_clear_dirty(ram_addr_t start, 
        mr_offset = (ram_addr_t)(page << TARGET_PAGE_BITS) - ramblock->offset;

        mr_size = (end - page) << TARGET_PAGE_BITS;

        memory_region_clear_dirty_bitmap(ramblock->mr, mr_offset, mr_size);



    rcu_read_unlock();

    }



    if (dirty && tcg_enabled()) {

        tlb_reset_dirty_range_all(start, length);
@@ -1411,14 +1407,14 @@ DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty 
    end  = last  >> TARGET_PAGE_BITS;

    dest = 0;



    rcu_read_lock();



    WITH_RCU_READ_LOCK_GUARD() {

        blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);



        while (page < end) {

            unsigned long idx = page / DIRTY_MEMORY_BLOCK_SIZE;

            unsigned long offset = page % DIRTY_MEMORY_BLOCK_SIZE;

        unsigned long num = MIN(end - page, DIRTY_MEMORY_BLOCK_SIZE - offset);

            unsigned long num = MIN(end - page,

                                    DIRTY_MEMORY_BLOCK_SIZE - offset);



            assert(QEMU_IS_ALIGNED(offset, (1 << BITS_PER_LEVEL)));

            assert(QEMU_IS_ALIGNED(num,    (1 << BITS_PER_LEVEL)));
@@ -1430,8 +1426,7 @@ DirtyBitmapSnapshot *cpu_physical_memory_snapshot_and_clear_dirty 
            page += num;

            dest += num >> BITS_PER_LEVEL;

        }



    rcu_read_unlock();

    }



    if (tcg_enabled()) {

        tlb_reset_dirty_range_all(start, length);
@@ -1643,7 +1638,7 @@ void ram_block_dump(Monitor *mon) 
    RAMBlock *block;

    char *psize;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    monitor_printf(mon, "%24s %8s  %18s %18s %18s\n",

                   "Block Name", "PSize", "Offset", "Used", "Total");

    RAMBLOCK_FOREACH(block) {
@@ -1655,7 +1650,6 @@ void ram_block_dump(Monitor *mon) 
                       (uint64_t)block->max_length);

        g_free(psize);

    }

    rcu_read_unlock();

}



#ifdef __linux__
@@ -2009,11 +2003,10 @@ static unsigned long last_ram_page(void) 
    RAMBlock *block;

    ram_addr_t last = 0;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    RAMBLOCK_FOREACH(block) {

        last = MAX(last, block->offset + block->max_length);

    }

    rcu_read_unlock();

    return last >> TARGET_PAGE_BITS;

}
@@ -2100,7 +2093,7 @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) 
    }

    pstrcat(new_block->idstr, sizeof(new_block->idstr), name);



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    RAMBLOCK_FOREACH(block) {

        if (block != new_block &&

            !strcmp(block->idstr, new_block->idstr)) {
@@ -2109,7 +2102,6 @@ void qemu_ram_set_idstr(RAMBlock *new_block, const char *name, DeviceState *dev) 
            abort();

        }

    }

    rcu_read_unlock();

}



/* Called with iothread lock held.  */
@@ -2651,17 +2643,16 @@ RAMBlock *qemu_ram_block_from_host(void *ptr, bool round_offset, 


    if (xen_enabled()) {

        ram_addr_t ram_addr;

        rcu_read_lock();

        RCU_READ_LOCK_GUARD();

        ram_addr = xen_ram_addr_from_mapcache(ptr);

        block = qemu_get_ram_block(ram_addr);

        if (block) {

            *offset = ram_addr - block->offset;

        }

        rcu_read_unlock();

        return block;

    }



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    block = atomic_rcu_read(&ram_list.mru_block);

    if (block && block->host && host - block->host < block->max_length) {

        goto found;
@@ -2677,7 +2668,6 @@ RAMBlock *qemu_ram_block_from_host(void *ptr, bool round_offset, 
        }

    }



    rcu_read_unlock();

    return NULL;



found:
@@ -2685,7 +2675,6 @@ found: 
    if (round_offset) {

        *offset &= TARGET_PAGE_MASK;

    }

    rcu_read_unlock();

    return block;

}
@@ -3281,10 +3270,9 @@ MemTxResult address_space_read_full(AddressSpace *as, hwaddr addr, 
    FlatView *fv;



    if (len > 0) {

        rcu_read_lock();

        RCU_READ_LOCK_GUARD();

        fv = address_space_to_flatview(as);

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

        rcu_read_unlock();

    }



    return result;
@@ -3298,10 +3286,9 @@ MemTxResult address_space_write(AddressSpace *as, hwaddr addr, 
    FlatView *fv;



    if (len > 0) {

        rcu_read_lock();

        RCU_READ_LOCK_GUARD();

        fv = address_space_to_flatview(as);

        result = flatview_write(fv, addr, attrs, buf, len);

        rcu_read_unlock();

    }



    return result;
@@ -3341,7 +3328,7 @@ static inline MemTxResult address_space_write_rom_internal(AddressSpace *as, 
    hwaddr addr1;

    MemoryRegion *mr;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    while (len > 0) {

        l = len;

        mr = address_space_translate(as, addr, &addr1, &l, true, attrs);
@@ -3366,7 +3353,6 @@ static inline MemTxResult address_space_write_rom_internal(AddressSpace *as, 
        buf += l;

        addr += l;

    }

    rcu_read_unlock();

    return MEMTX_OK;

}
@@ -3511,10 +3497,9 @@ bool address_space_access_valid(AddressSpace *as, hwaddr addr, 
    FlatView *fv;

    bool result;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    fv = address_space_to_flatview(as);

    result = flatview_access_valid(fv, addr, len, is_write, attrs);

    rcu_read_unlock();

    return result;

}
@@ -3569,13 +3554,12 @@ void *address_space_map(AddressSpace *as, 
    }



    l = len;

    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    fv = address_space_to_flatview(as);

    mr = flatview_translate(fv, addr, &xlat, &l, is_write, attrs);



    if (!memory_access_is_direct(mr, is_write)) {

        if (atomic_xchg(&bounce.in_use, true)) {

            rcu_read_unlock();

            return NULL;

        }

        /* Avoid unbounded allocations */
@@ -3591,7 +3575,6 @@ void *address_space_map(AddressSpace *as, 
                               bounce.buffer, l);

        }



        rcu_read_unlock();

        *plen = l;

        return bounce.buffer;

    }
@@ -3601,7 +3584,6 @@ void *address_space_map(AddressSpace *as, 
    *plen = flatview_extend_translation(fv, addr, len, mr, xlat,

                                        l, is_write, attrs);

    ptr = qemu_ram_ptr_length(mr->ram_block, xlat, plen, true);

    rcu_read_unlock();



    return ptr;

}
@@ -3869,13 +3851,12 @@ bool cpu_physical_memory_is_io(hwaddr phys_addr) 
    hwaddr l = 1;

    bool res;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    mr = address_space_translate(&address_space_memory,

                                 phys_addr, &phys_addr, &l, false,

                                 MEMTXATTRS_UNSPECIFIED);



    res = !(memory_region_is_ram(mr) || memory_region_is_romd(mr));

    rcu_read_unlock();

    return res;

}
@@ -3884,14 +3865,13 @@ int qemu_ram_foreach_block(RAMBlockIterFunc func, void *opaque) 
    RAMBlock *block;

    int ret = 0;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();

    RAMBLOCK_FOREACH(block) {

        ret = func(block, opaque);

        if (ret) {

            break;

        }

    }

    rcu_read_unlock();

    return ret;

}

include/exec/ram_addr.h

+65 −73
Original line number Diff line number Diff line
@@ -193,8 +193,7 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, 
    end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;

    page = start >> TARGET_PAGE_BITS;



    rcu_read_lock();



    WITH_RCU_READ_LOCK_GUARD() {

        blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);



        idx = page / DIRTY_MEMORY_BLOCK_SIZE;
@@ -203,7 +202,8 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, 
        while (page < end) {

            unsigned long next = MIN(end, base + DIRTY_MEMORY_BLOCK_SIZE);

            unsigned long num = next - base;

        unsigned long found = find_next_bit(blocks->blocks[idx], num, offset);

            unsigned long found = find_next_bit(blocks->blocks[idx],

                                                num, offset);

            if (found < num) {

                dirty = true;

                break;
@@ -214,8 +214,7 @@ static inline bool cpu_physical_memory_get_dirty(ram_addr_t start, 
            offset = 0;

            base += DIRTY_MEMORY_BLOCK_SIZE;

        }



    rcu_read_unlock();

    }



    return dirty;

}
@@ -234,7 +233,7 @@ static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, 
    end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;

    page = start >> TARGET_PAGE_BITS;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();



    blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);
@@ -256,8 +255,6 @@ static inline bool cpu_physical_memory_all_dirty(ram_addr_t start, 
        base += DIRTY_MEMORY_BLOCK_SIZE;

    }



    rcu_read_unlock();



    return dirty;

}
@@ -309,13 +306,11 @@ static inline void cpu_physical_memory_set_dirty_flag(ram_addr_t addr, 
    idx = page / DIRTY_MEMORY_BLOCK_SIZE;

    offset = page % DIRTY_MEMORY_BLOCK_SIZE;



    rcu_read_lock();

    RCU_READ_LOCK_GUARD();



    blocks = atomic_rcu_read(&ram_list.dirty_memory[client]);



    set_bit_atomic(offset, blocks->blocks[idx]);



    rcu_read_unlock();

}



static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start,
@@ -334,8 +329,7 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, 
    end = TARGET_PAGE_ALIGN(start + length) >> TARGET_PAGE_BITS;

    page = start >> TARGET_PAGE_BITS;



    rcu_read_lock();



    WITH_RCU_READ_LOCK_GUARD() {

        for (i = 0; i < DIRTY_MEMORY_NUM; i++) {

            blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i]);

        }
@@ -364,8 +358,7 @@ static inline void cpu_physical_memory_set_dirty_range(ram_addr_t start, 
            offset = 0;

            base += DIRTY_MEMORY_BLOCK_SIZE;

        }



    rcu_read_unlock();

    }



    xen_hvm_modified_memory(start, length);

}
@@ -396,8 +389,7 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, 
        offset = BIT_WORD((start >> TARGET_PAGE_BITS) %

                          DIRTY_MEMORY_BLOCK_SIZE);



        rcu_read_lock();



        WITH_RCU_READ_LOCK_GUARD() {

            for (i = 0; i < DIRTY_MEMORY_NUM; i++) {

                blocks[i] = atomic_rcu_read(&ram_list.dirty_memory[i])->blocks;

            }
@@ -414,7 +406,8 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, 
                    }



                    if (tcg_enabled()) {

                    atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset], temp);

                        atomic_or(&blocks[DIRTY_MEMORY_CODE][idx][offset],

                                  temp);

                    }

                }
@@ -423,8 +416,7 @@ static inline void cpu_physical_memory_set_dirty_lebitmap(unsigned long *bitmap, 
                    idx++;

                }

            }



        rcu_read_unlock();

        }



        xen_hvm_modified_memory(start, pages << TARGET_PAGE_BITS);

    } else {

include/migration/misc.h

+1 −0
Original line number Diff line number Diff line
@@ -60,6 +60,7 @@ void migration_object_init(void); 
void migration_shutdown(void);

void qemu_start_incoming_migration(const char *uri, Error **errp);

bool migration_is_idle(void);

bool migration_is_active(MigrationState *);

void add_migration_state_change_notifier(Notifier *notify);

void remove_migration_state_change_notifier(Notifier *notify);

bool migration_in_setup(MigrationState *);

include/migration/vmstate.h

+40 −0
Original line number Diff line number Diff line
@@ -224,6 +224,7 @@ extern const VMStateInfo vmstate_info_unused_buffer; 
extern const VMStateInfo vmstate_info_tmp;

extern const VMStateInfo vmstate_info_bitmap;

extern const VMStateInfo vmstate_info_qtailq;

extern const VMStateInfo vmstate_info_gtree;



#define type_check_2darray(t1,t2,n,m) ((t1(*)[n][m])0 - (t2*)0)

/*
@@ -754,6 +755,45 @@ extern const VMStateInfo vmstate_info_qtailq; 
    .start        = offsetof(_type, _next),                              \

}



/*

 * For migrating a GTree whose key is a pointer to _key_type and the

 * value, a pointer to _val_type

 * The target tree must have been properly initialized

 * _vmsd: Start address of the 2 element array containing the data vmsd

 *        and the key vmsd, in that order

 * _key_type: type of the key

 * _val_type: type of the value

 */

#define VMSTATE_GTREE_V(_field, _state, _version, _vmsd,                       \

                        _key_type, _val_type)                                  \

{                                                                              \

    .name         = (stringify(_field)),                                       \

    .version_id   = (_version),                                                \

    .vmsd         = (_vmsd),                                                   \

    .info         = &vmstate_info_gtree,                                       \

    .start        = sizeof(_key_type),                                         \

    .size         = sizeof(_val_type),                                         \

    .offset       = offsetof(_state, _field),                                  \

}



/*

 * For migrating a GTree with direct key and the value a pointer

 * to _val_type

 * The target tree must have been properly initialized

 * _vmsd: data vmsd

 * _val_type: type of the value

 */

#define VMSTATE_GTREE_DIRECT_KEY_V(_field, _state, _version, _vmsd, _val_type) \

{                                                                              \

    .name         = (stringify(_field)),                                       \

    .version_id   = (_version),                                                \

    .vmsd         = (_vmsd),                                                   \

    .info         = &vmstate_info_gtree,                                       \

    .start        = 0,                                                         \

    .size         = sizeof(_val_type),                                         \

    .offset       = offsetof(_state, _field),                                  \

}



/* _f : field name

   _f_n : num of elements field_name

   _n : num of elements