Commit 6bc56d31 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/bonzini/tags/for-upstream-mttcg' into staging 



Base patches for MTTCG enablement.

# gpg: Signature made Mon 31 Oct 2016 14:01:41 GMT
# gpg:                using RSA key 0xBFFBD25F78C7AE83
# gpg: Good signature from "Paolo Bonzini <bonzini@gnu.org>"
# gpg:                 aka "Paolo Bonzini <pbonzini@redhat.com>"
# Primary key fingerprint: 46F5 9FBD 57D6 12E7 BFD4  E2F7 7E15 100C CD36 69B1
#      Subkey fingerprint: F133 3857 4B66 2389 866C  7682 BFFB D25F 78C7 AE83

* remotes/bonzini/tags/for-upstream-mttcg:
  tcg: move locking for tb_invalidate_phys_page_range up
  *_run_on_cpu: introduce run_on_cpu_data type
  cpus: re-factor out handle_icount_deadline
  tcg: cpus rm tcg_exec_all()
  tcg: move tcg_exec_all and helpers above thread fn
  target-arm/arm-powerctl: wake up sleeping CPUs
  tcg: protect translation related stuff with tb_lock.
  translate-all: Add assert_(memory|tb)_lock annotations
  linux-user/elfload: ensure mmap_lock() held while setting up
  tcg: comment on which functions have to be called with tb_lock held
  cpu-exec: include cpu_index in CPU_LOG_EXEC messages
  translate-all: add DEBUG_LOCKING asserts
  translate_all: DEBUG_FLUSH -> DEBUG_TB_FLUSH
  cpus: make all_vcpus_paused() return bool

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 0bb11379 ba051fb5

bsd-user/mmap.c

+5 −0
Original line number Diff line number Diff line
@@ -42,6 +42,11 @@ void mmap_unlock(void) 
    }

}



bool have_mmap_lock(void)

{

    return mmap_lock_count > 0 ? true : false;

}



/* Grab lock to make sure things are in a consistent state after fork().  */

void mmap_fork_start(void)

{

cpu-exec.c

+9 −2
Original line number Diff line number Diff line
@@ -143,8 +143,9 @@ static inline tcg_target_ulong cpu_tb_exec(CPUState *cpu, TranslationBlock *itb) 
    uint8_t *tb_ptr = itb->tc_ptr;



    qemu_log_mask_and_addr(CPU_LOG_EXEC, itb->pc,

                           "Trace %p [" TARGET_FMT_lx "] %s\n",

                           itb->tc_ptr, itb->pc, lookup_symbol(itb->pc));

                           "Trace %p [%d: " TARGET_FMT_lx "] %s\n",

                           itb->tc_ptr, cpu->cpu_index, itb->pc,

                           lookup_symbol(itb->pc));



#if defined(DEBUG_DISAS)

    if (qemu_loglevel_mask(CPU_LOG_TB_CPU)
@@ -204,15 +205,21 @@ static void cpu_exec_nocache(CPUState *cpu, int max_cycles, 
    if (max_cycles > CF_COUNT_MASK)

        max_cycles = CF_COUNT_MASK;



    tb_lock();

    tb = tb_gen_code(cpu, orig_tb->pc, orig_tb->cs_base, orig_tb->flags,

                     max_cycles | CF_NOCACHE

                         | (ignore_icount ? CF_IGNORE_ICOUNT : 0));

    tb->orig_tb = orig_tb;

    tb_unlock();



    /* execute the generated code */

    trace_exec_tb_nocache(tb, tb->pc);

    cpu_tb_exec(cpu, tb);



    tb_lock();

    tb_phys_invalidate(tb, -1);

    tb_free(tb);

    tb_unlock();

}

#endif

cpus-common.c

+5 −4
Original line number Diff line number Diff line
@@ -109,7 +109,7 @@ void cpu_list_remove(CPUState *cpu) 
struct qemu_work_item {

    struct qemu_work_item *next;

    run_on_cpu_func func;

    void *data;

    run_on_cpu_data data;

    bool free, exclusive, done;

};
@@ -129,7 +129,7 @@ static void queue_work_on_cpu(CPUState *cpu, struct qemu_work_item *wi) 
    qemu_cpu_kick(cpu);

}



void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data,

void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data,

                   QemuMutex *mutex)

{

    struct qemu_work_item wi;
@@ -154,7 +154,7 @@ void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data, 
    }

}



void async_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data)

void async_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)

{

    struct qemu_work_item *wi;
@@ -296,7 +296,8 @@ void cpu_exec_end(CPUState *cpu) 
    }

}



void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data)

void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func,

                           run_on_cpu_data data)

{

    struct qemu_work_item *wi;

cpus.c

+132 −127
Original line number Diff line number Diff line
@@ -69,7 +69,6 @@ 


#endif /* CONFIG_LINUX */



static CPUState *next_cpu;

int64_t max_delay;

int64_t max_advance;
@@ -557,7 +556,7 @@ static const VMStateDescription vmstate_timers = { 
    }

};



static void cpu_throttle_thread(CPUState *cpu, void *opaque)

static void cpu_throttle_thread(CPUState *cpu, run_on_cpu_data opaque)

{

    double pct;

    double throttle_ratio;
@@ -588,7 +587,8 @@ static void cpu_throttle_timer_tick(void *opaque) 
    }

    CPU_FOREACH(cpu) {

        if (!atomic_xchg(&cpu->throttle_thread_scheduled, 1)) {

            async_run_on_cpu(cpu, cpu_throttle_thread, NULL);

            async_run_on_cpu(cpu, cpu_throttle_thread,

                             RUN_ON_CPU_NULL);

        }

    }
@@ -915,7 +915,7 @@ void qemu_init_cpu_loop(void) 
    qemu_thread_get_self(&io_thread);

}



void run_on_cpu(CPUState *cpu, run_on_cpu_func func, void *data)

void run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data)

{

    do_run_on_cpu(cpu, func, data, &qemu_global_mutex);

}
@@ -1055,12 +1055,102 @@ static void *qemu_dummy_cpu_thread_fn(void *arg) 
#endif

}



static void tcg_exec_all(void);

static int64_t tcg_get_icount_limit(void)

{

    int64_t deadline;



    if (replay_mode != REPLAY_MODE_PLAY) {

        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);



        /* Maintain prior (possibly buggy) behaviour where if no deadline

         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than

         * INT32_MAX nanoseconds ahead, we still use INT32_MAX

         * nanoseconds.

         */

        if ((deadline < 0) || (deadline > INT32_MAX)) {

            deadline = INT32_MAX;

        }



        return qemu_icount_round(deadline);

    } else {

        return replay_get_instructions();

    }

}



static void handle_icount_deadline(void)

{

    if (use_icount) {

        int64_t deadline =

            qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);



        if (deadline == 0) {

            qemu_clock_notify(QEMU_CLOCK_VIRTUAL);

        }

    }

}



static int tcg_cpu_exec(CPUState *cpu)

{

    int ret;

#ifdef CONFIG_PROFILER

    int64_t ti;

#endif



#ifdef CONFIG_PROFILER

    ti = profile_getclock();

#endif

    if (use_icount) {

        int64_t count;

        int decr;

        timers_state.qemu_icount -= (cpu->icount_decr.u16.low

                                    + cpu->icount_extra);

        cpu->icount_decr.u16.low = 0;

        cpu->icount_extra = 0;

        count = tcg_get_icount_limit();

        timers_state.qemu_icount += count;

        decr = (count > 0xffff) ? 0xffff : count;

        count -= decr;

        cpu->icount_decr.u16.low = decr;

        cpu->icount_extra = count;

    }

    cpu_exec_start(cpu);

    ret = cpu_exec(cpu);

    cpu_exec_end(cpu);

#ifdef CONFIG_PROFILER

    tcg_time += profile_getclock() - ti;

#endif

    if (use_icount) {

        /* Fold pending instructions back into the

           instruction counter, and clear the interrupt flag.  */

        timers_state.qemu_icount -= (cpu->icount_decr.u16.low

                        + cpu->icount_extra);

        cpu->icount_decr.u32 = 0;

        cpu->icount_extra = 0;

        replay_account_executed_instructions();

    }

    return ret;

}



/* Destroy any remaining vCPUs which have been unplugged and have

 * finished running

 */

static void deal_with_unplugged_cpus(void)

{

    CPUState *cpu;



    CPU_FOREACH(cpu) {

        if (cpu->unplug && !cpu_can_run(cpu)) {

            qemu_tcg_destroy_vcpu(cpu);

            cpu->created = false;

            qemu_cond_signal(&qemu_cpu_cond);

            break;

        }

    }

}



static void *qemu_tcg_cpu_thread_fn(void *arg)

{

    CPUState *cpu = arg;

    CPUState *remove_cpu = NULL;



    rcu_register_thread();
@@ -1087,29 +1177,44 @@ static void *qemu_tcg_cpu_thread_fn(void *arg) 
    /* process any pending work */

    atomic_mb_set(&exit_request, 1);



    while (1) {

        tcg_exec_all();

    cpu = first_cpu;



        if (use_icount) {

            int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);

    while (1) {

        /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */

        qemu_account_warp_timer();



            if (deadline == 0) {

                qemu_clock_notify(QEMU_CLOCK_VIRTUAL);

            }

        if (!cpu) {

            cpu = first_cpu;

        }

        qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));

        CPU_FOREACH(cpu) {

            if (cpu->unplug && !cpu_can_run(cpu)) {

                remove_cpu = cpu;



        for (; cpu != NULL && !exit_request; cpu = CPU_NEXT(cpu)) {



            qemu_clock_enable(QEMU_CLOCK_VIRTUAL,

                              (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);



            if (cpu_can_run(cpu)) {

                int r;

                r = tcg_cpu_exec(cpu);

                if (r == EXCP_DEBUG) {

                    cpu_handle_guest_debug(cpu);

                    break;

                }

            } else if (cpu->stop || cpu->stopped) {

                if (cpu->unplug) {

                    cpu = CPU_NEXT(cpu);

                }

        if (remove_cpu) {

            qemu_tcg_destroy_vcpu(remove_cpu);

            cpu->created = false;

            qemu_cond_signal(&qemu_cpu_cond);

            remove_cpu = NULL;

                break;

            }



        } /* for cpu.. */



        /* Pairs with smp_wmb in qemu_cpu_kick.  */

        atomic_mb_set(&exit_request, 0);



        handle_icount_deadline();



        qemu_tcg_wait_io_event(QTAILQ_FIRST(&cpus));

        deal_with_unplugged_cpus();

    }



    return NULL;
@@ -1207,17 +1312,17 @@ void qemu_mutex_unlock_iothread(void) 
    qemu_mutex_unlock(&qemu_global_mutex);

}



static int all_vcpus_paused(void)

static bool all_vcpus_paused(void)

{

    CPUState *cpu;



    CPU_FOREACH(cpu) {

        if (!cpu->stopped) {

            return 0;

            return false;

        }

    }



    return 1;

    return true;

}



void pause_all_vcpus(void)
@@ -1412,106 +1517,6 @@ int vm_stop_force_state(RunState state) 
    }

}



static int64_t tcg_get_icount_limit(void)

{

    int64_t deadline;



    if (replay_mode != REPLAY_MODE_PLAY) {

        deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);



        /* Maintain prior (possibly buggy) behaviour where if no deadline

         * was set (as there is no QEMU_CLOCK_VIRTUAL timer) or it is more than

         * INT32_MAX nanoseconds ahead, we still use INT32_MAX

         * nanoseconds.

         */

        if ((deadline < 0) || (deadline > INT32_MAX)) {

            deadline = INT32_MAX;

        }



        return qemu_icount_round(deadline);

    } else {

        return replay_get_instructions();

    }

}



static int tcg_cpu_exec(CPUState *cpu)

{

    int ret;

#ifdef CONFIG_PROFILER

    int64_t ti;

#endif



#ifdef CONFIG_PROFILER

    ti = profile_getclock();

#endif

    if (use_icount) {

        int64_t count;

        int decr;

        timers_state.qemu_icount -= (cpu->icount_decr.u16.low

                                    + cpu->icount_extra);

        cpu->icount_decr.u16.low = 0;

        cpu->icount_extra = 0;

        count = tcg_get_icount_limit();

        timers_state.qemu_icount += count;

        decr = (count > 0xffff) ? 0xffff : count;

        count -= decr;

        cpu->icount_decr.u16.low = decr;

        cpu->icount_extra = count;

    }

    cpu_exec_start(cpu);

    ret = cpu_exec(cpu);

    cpu_exec_end(cpu);

#ifdef CONFIG_PROFILER

    tcg_time += profile_getclock() - ti;

#endif

    if (use_icount) {

        /* Fold pending instructions back into the

           instruction counter, and clear the interrupt flag.  */

        timers_state.qemu_icount -= (cpu->icount_decr.u16.low

                        + cpu->icount_extra);

        cpu->icount_decr.u32 = 0;

        cpu->icount_extra = 0;

        replay_account_executed_instructions();

    }

    return ret;

}



static void tcg_exec_all(void)

{

    int r;



    /* Account partial waits to QEMU_CLOCK_VIRTUAL.  */

    qemu_account_warp_timer();



    if (next_cpu == NULL) {

        next_cpu = first_cpu;

    }

    for (; next_cpu != NULL && !exit_request; next_cpu = CPU_NEXT(next_cpu)) {

        CPUState *cpu = next_cpu;



        qemu_clock_enable(QEMU_CLOCK_VIRTUAL,

                          (cpu->singlestep_enabled & SSTEP_NOTIMER) == 0);



        if (cpu_can_run(cpu)) {

            r = tcg_cpu_exec(cpu);

            if (r == EXCP_DEBUG) {

                cpu_handle_guest_debug(cpu);

                break;

            } else if (r == EXCP_ATOMIC) {

                cpu_exec_step_atomic(cpu);

            }

        } else if (cpu->stop || cpu->stopped) {

            if (cpu->unplug) {

                next_cpu = CPU_NEXT(cpu);

            }

            break;

        }

    }



    /* Pairs with smp_wmb in qemu_cpu_kick.  */

    atomic_mb_set(&exit_request, 0);

}



void list_cpus(FILE *f, fprintf_function cpu_fprintf, const char *optarg)

{

    /* XXX: implement xxx_cpu_list for targets that still miss it */

exec.c

+22 −0
Original line number Diff line number Diff line
@@ -687,7 +687,11 @@ void cpu_exec_realizefn(CPUState *cpu, Error **errp) 
#if defined(CONFIG_USER_ONLY)

static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)

{

    mmap_lock();

    tb_lock();

    tb_invalidate_phys_page_range(pc, pc + 1, 0);

    tb_unlock();

    mmap_unlock();

}

#else

static void breakpoint_invalidate(CPUState *cpu, target_ulong pc)
@@ -696,6 +700,7 @@ static void breakpoint_invalidate(CPUState *cpu, target_ulong pc) 
    hwaddr phys = cpu_get_phys_page_attrs_debug(cpu, pc, &attrs);

    int asidx = cpu_asidx_from_attrs(cpu, attrs);

    if (phys != -1) {

        /* Locks grabbed by tb_invalidate_phys_addr */

        tb_invalidate_phys_addr(cpu->cpu_ases[asidx].as,

                                phys | (pc & ~TARGET_PAGE_MASK));

    }
@@ -1988,7 +1993,11 @@ ram_addr_t qemu_ram_addr_from_host(void *ptr) 
static void notdirty_mem_write(void *opaque, hwaddr ram_addr,

                               uint64_t val, unsigned size)

{

    bool locked = false;



    if (!cpu_physical_memory_get_dirty_flag(ram_addr, DIRTY_MEMORY_CODE)) {

        locked = true;

        tb_lock();

        tb_invalidate_phys_page_fast(ram_addr, size);

    }

    switch (size) {
@@ -2004,6 +2013,11 @@ static void notdirty_mem_write(void *opaque, hwaddr ram_addr, 
    default:

        abort();

    }



    if (locked) {

        tb_unlock();

    }



    /* Set both VGA and migration bits for simplicity and to remove

     * the notdirty callback faster.

     */
@@ -2064,6 +2078,12 @@ static void check_watchpoint(int offset, int len, MemTxAttrs attrs, int flags) 
                    continue;

                }

                cpu->watchpoint_hit = wp;



                /* The tb_lock will be reset when cpu_loop_exit or

                 * cpu_loop_exit_noexc longjmp back into the cpu_exec

                 * main loop.

                 */

                tb_lock();

                tb_check_watchpoint(cpu);

                if (wp->flags & BP_STOP_BEFORE_ACCESS) {

                    cpu->exception_index = EXCP_DEBUG;
@@ -2471,7 +2491,9 @@ static void invalidate_and_set_dirty(MemoryRegion *mr, hwaddr addr, 
            cpu_physical_memory_range_includes_clean(addr, length, dirty_log_mask);

    }

    if (dirty_log_mask & (1 << DIRTY_MEMORY_CODE)) {

        tb_lock();

        tb_invalidate_phys_range(addr, addr + length);

        tb_unlock();

        dirty_log_mask &= ~(1 << DIRTY_MEMORY_CODE);

    }

    cpu_physical_memory_set_dirty_range(addr, length, dirty_log_mask);