Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
37 changes: 19 additions & 18 deletions accel/tcg/cputlb.c
Original file line number Diff line number Diff line change
Expand Up @@ -435,11 +435,23 @@ void tlb_flush_all_cpus_synced(CPUState *src_cpu)
tlb_flush_by_mmuidx_all_cpus_synced(src_cpu, ALL_MMUIDX_BITS);
}

/**
* tlb_entry_is_empty - return true if the entry is not in use
* @te: pointer to CPUTLBEntry
*/
static inline bool tlb_entry_is_empty(const CPUTLBEntry *te)
{
return te->addr_read == -1 && te->addr_write == -1 && te->addr_code == -1;
}

static bool tlb_hit_page_mask_anyprot(CPUTLBEntry *tlb_entry,
vaddr page, vaddr mask)
{
page &= mask;
mask &= TARGET_PAGE_MASK | TLB_INVALID_MASK;
if (tlb_entry_is_empty(tlb_entry)) {
return false;
}
page &= mask & TARGET_PAGE_MASK;
mask &= TARGET_PAGE_MASK;

return (page == (tlb_entry->addr_read & mask) ||
page == (tlb_addr_write(tlb_entry) & mask) ||
Expand All @@ -451,15 +463,6 @@ static inline bool tlb_hit_page_anyprot(CPUTLBEntry *tlb_entry, vaddr page)
return tlb_hit_page_mask_anyprot(tlb_entry, page, -1);
}

/**
* tlb_entry_is_empty - return true if the entry is not in use
* @te: pointer to CPUTLBEntry
*/
static inline bool tlb_entry_is_empty(const CPUTLBEntry *te)
{
return te->addr_read == -1 && te->addr_write == -1 && te->addr_code == -1;
}

/* Called with tlb_c.lock held */
static bool tlb_flush_entry_mask_locked(CPUTLBEntry *tlb_entry,
vaddr page,
Expand Down Expand Up @@ -1151,13 +1154,15 @@ void tlb_set_page_full(CPUState *cpu, int mmu_idx,
* subtract here is that of the page base, and not the same as the
* vaddr we add back in io_prepare()/get_page_addr_code().
*/
hwaddr ofs_diff = (full->phys_addr & ~TARGET_PAGE_MASK) -
(addr & ~TARGET_PAGE_MASK);
desc->fulltlb[index] = *full;
full = &desc->fulltlb[index];
full->xlat_section = iotlb - addr_page;
full->phys_addr = paddr_page;
full->phys_addr = paddr_page + ofs_diff;

/* Now calculate the new entry */
tn.addend = addend - addr_page;
tn.addend = addend - addr_page + ofs_diff;

tlb_set_compare(full, &tn, addr_page, read_flags,
MMU_INST_FETCH, prot & PAGE_EXEC);
Expand Down Expand Up @@ -1292,7 +1297,7 @@ static void io_failed(CPUState *cpu, CPUTLBEntryFull *full, vaddr addr,
{
if (!cpu->ignore_memory_transaction_failures
&& cpu->cc->tcg_ops->do_transaction_failed) {
hwaddr physaddr = full->phys_addr | (addr & ~TARGET_PAGE_MASK);
hwaddr physaddr = full->phys_addr + (addr & ~TARGET_PAGE_MASK);

cpu->cc->tcg_ops->do_transaction_failed(cpu, physaddr, addr, size,
access_type, mmu_idx,
Expand Down Expand Up @@ -1549,10 +1554,6 @@ tb_page_addr_t get_page_addr_code_hostp(CPUArchState *env, vaddr addr,
return -1;
}

if (full->lg_page_size < TARGET_PAGE_BITS) {
return -1;
}

if (hostp) {
*hostp = p;
}
Expand Down
42 changes: 42 additions & 0 deletions accel/tcg/icount-common.c
Original file line number Diff line number Diff line change
Expand Up @@ -154,11 +154,40 @@ int64_t icount_get(void)
return icount;
}

static uint64_t icount_freq_hz;

void icount_set_freq_hz(uint64_t freq_hz)
{
qatomic_set(&icount_freq_hz, freq_hz);
}

int64_t icount_to_ns(int64_t icount)
{
uint64_t freq = qatomic_read(&icount_freq_hz);
if (freq) {
return (int64_t)muldiv64(icount, NANOSECONDS_PER_SECOND, freq);
}
return icount << qatomic_read(&timers_state.icount_time_shift);
}

int64_t icount_get_cycles(void)
{
return icount_get_raw() +
icount_round(qatomic_read_i64(&timers_state.qemu_icount_bias));
}

void icount_advance_bias_ns(int64_t delta_ns)
{
if (delta_ns > 0 && icount_enabled()) {
seqlock_write_lock(&timers_state.vm_clock_seqlock,
&timers_state.vm_clock_lock);
qatomic_set_i64(&timers_state.qemu_icount_bias,
timers_state.qemu_icount_bias + delta_ns);
seqlock_write_unlock(&timers_state.vm_clock_seqlock,
&timers_state.vm_clock_lock);
}
}

/*
* Correlation between real and virtual time is always going to be
* fairly approximate, so ignore small variation.
Expand Down Expand Up @@ -225,6 +254,13 @@ static void icount_adjust_vm(void *opaque)

int64_t icount_round(int64_t count)
{
if (count <= 0) {
return 0;
}
uint64_t freq = qatomic_read(&icount_freq_hz);
if (freq) {
return (int64_t)muldiv64(count, freq, NANOSECONDS_PER_SECOND) ?: 1;
}
int shift = qatomic_read(&timers_state.icount_time_shift);
return (count + (1 << shift) - 1) >> shift;
}
Expand All @@ -247,6 +283,9 @@ static void icount_warp_rt(void)
return;
}

int64_t deadline = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL,
~QEMU_TIMER_ATTR_EXTERNAL);

seqlock_write_lock(&timers_state.vm_clock_seqlock,
&timers_state.vm_clock_lock);
if (runstate_is_running()) {
Expand All @@ -255,6 +294,9 @@ static void icount_warp_rt(void)
int64_t warp_delta;

warp_delta = clock - timers_state.vm_clock_warp_start;
if (deadline >= 0) {
warp_delta = MIN(warp_delta, deadline);
}
if (icount_enabled() == ICOUNT_ADAPTATIVE) {
/*
* In adaptive mode, do not let QEMU_CLOCK_VIRTUAL run too far
Expand Down
94 changes: 64 additions & 30 deletions hw/intc/sifive_plic.c
Original file line number Diff line number Diff line change
Expand Up @@ -91,10 +91,17 @@ static void sifive_plic_set_claimed(SiFivePLICState *plic, int irq, bool level)
}
}

static uint32_t sifive_plic_claimed(SiFivePLICState *plic, uint32_t addrid)
static bool sifive_plic_is_claimed(SiFivePLICState *plic, int irq)
{
return (plic->claimed[irq >> 5] & (1 << (irq & 31))) != 0;
}

static uint32_t sifive_plic_claimed(SiFivePLICState *plic, uint32_t addrid,
bool ignore_threshold)
{
uint32_t max_irq = 0;
uint32_t max_prio = plic->target_priority[addrid];
uint32_t max_prio = ignore_threshold ? 0 : plic->target_priority[addrid];
bool found = false;
int i, j;
int num_irq_in_word = 32;

Expand All @@ -121,7 +128,8 @@ static uint32_t sifive_plic_claimed(SiFivePLICState *plic, uint32_t addrid)
uint32_t prio = plic->source_priority[irq];
int enabled = pending_enabled_not_claimed & (1 << j);

if (enabled && prio > max_prio) {
if (enabled && ((ignore_threshold && !found) || prio > max_prio)) {
found = true;
max_irq = irq;
max_prio = prio;
}
Expand All @@ -139,7 +147,7 @@ static void sifive_plic_update(SiFivePLICState *plic)
for (addrid = 0; addrid < plic->num_addrs; addrid++) {
uint32_t hartid = plic->addr_config[addrid].hartid;
PLICMode mode = plic->addr_config[addrid].mode;
bool level = !!sifive_plic_claimed(plic, addrid);
bool level = !!sifive_plic_claimed(plic, addrid, false);

switch (mode) {
case PLICMode_M:
Expand All @@ -156,6 +164,34 @@ static void sifive_plic_update(SiFivePLICState *plic)
}
}

static bool sifive_plic_accepts(void *opaque, hwaddr addr, unsigned size,
bool is_write, MemTxAttrs attrs)
{
SiFivePLICState *plic = opaque;
uint32_t reg_be = ((1u << size) - 1u) << (addr & 3u);
uint32_t permit = 0;

if (addr_between(addr, plic->priority_base, plic->num_sources << 2)) {
permit = 0x1u;
} else if (addr_between(addr, plic->pending_base,
plic->bitfield_words << 2)) {
permit = 0xfu;
} else if (addr_between(addr, plic->enable_base,
plic->num_addrs * plic->enable_stride)) {
if (((addr & (plic->enable_stride - 1)) >> 2) <
plic->bitfield_words) {
permit = 0xfu;
}
} else if (addr_between(addr, plic->context_base,
plic->num_addrs * plic->context_stride)) {
uint32_t contextid = addr & (plic->context_stride - 4);
if (contextid == 0 || contextid == 4) {
permit = 0x1u;
}
}
return permit != 0 && (!is_write || !(permit & ~reg_be));
}

static uint64_t sifive_plic_read(void *opaque, hwaddr addr, unsigned size)
{
SiFivePLICState *plic = opaque;
Expand All @@ -165,7 +201,7 @@ static uint64_t sifive_plic_read(void *opaque, hwaddr addr, unsigned size)

return plic->source_priority[irq];
} else if (addr_between(addr, plic->pending_base,
(plic->num_sources + 31) >> 3)) {
plic->bitfield_words << 2)) {
uint32_t word = (addr - plic->pending_base) >> 2;

return plic->pending[word];
Expand All @@ -185,7 +221,7 @@ static uint64_t sifive_plic_read(void *opaque, hwaddr addr, unsigned size)
if (contextid == 0) {
return plic->target_priority[addrid];
} else if (contextid == 4) {
uint32_t max_irq = sifive_plic_claimed(plic, addrid);
uint32_t max_irq = sifive_plic_claimed(plic, addrid, true);

if (max_irq) {
sifive_plic_set_pending(plic, max_irq, false);
Expand All @@ -210,13 +246,7 @@ static void sifive_plic_write(void *opaque, hwaddr addr, uint64_t value,

if (addr_between(addr, plic->priority_base, plic->num_sources << 2)) {
uint32_t irq = (addr - plic->priority_base) >> 2;
if (irq == 0) {
/* IRQ 0 source prioority is reserved */
qemu_log_mask(LOG_GUEST_ERROR,
"%s: Invalid source priority write 0x%"
HWADDR_PRIx "\n", __func__, addr);
return;
} else if (((plic->num_priorities + 1) & plic->num_priorities) == 0) {
if (((plic->num_priorities + 1) & plic->num_priorities) == 0) {
/*
* if "num_priorities + 1" is power-of-2, make each register bit of
* interrupt priority WARL (Write-Any-Read-Legal). Just filter
Expand All @@ -231,7 +261,7 @@ static void sifive_plic_write(void *opaque, hwaddr addr, uint64_t value,
sifive_plic_update(plic);
}
} else if (addr_between(addr, plic->pending_base,
(plic->num_sources + 31) >> 3)) {
plic->bitfield_words << 2)) {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: invalid pending write: 0x%" HWADDR_PRIx "",
__func__, addr);
Expand All @@ -241,12 +271,12 @@ static void sifive_plic_write(void *opaque, hwaddr addr, uint64_t value,
uint32_t wordid = (addr & (plic->enable_stride - 1)) >> 2;

if (wordid < plic->bitfield_words) {
if (wordid == (plic->bitfield_words - 1) &&
(plic->num_sources & 31)) {
value &= (1u << (plic->num_sources & 31)) - 1u;
}
plic->enable[addrid * plic->bitfield_words + wordid] = value;
sifive_plic_update(plic);
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: Invalid enable write 0x%" HWADDR_PRIx "\n",
__func__, addr);
}
} else if (addr_between(addr, plic->context_base,
plic->num_addrs * plic->context_stride)) {
Expand All @@ -268,29 +298,32 @@ static void sifive_plic_write(void *opaque, hwaddr addr, uint64_t value,
sifive_plic_update(plic);
}
} else if (contextid == 4) {
if (value < plic->num_sources) {
uint32_t src_bits = (plic->num_sources > 1u) ?
(32u - clz32(plic->num_sources - 1u)) :
1u;
value &= (src_bits >= 32u) ? 0xffffffffu : ((1u << src_bits) - 1u);
if (value < plic->num_sources &&
sifive_plic_is_claimed(plic, value)) {
sifive_plic_set_claimed(plic, value, false);
if (!plic->edge_triggered &&
sifive_plic_get_level(plic, value)) {
sifive_plic_set_pending(plic, value, true);
}
sifive_plic_update(plic);
}
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: Invalid context write 0x%" HWADDR_PRIx "\n",
__func__, addr);
}
} else {
qemu_log_mask(LOG_GUEST_ERROR,
"%s: Invalid register write 0x%" HWADDR_PRIx "\n",
__func__, addr);
}
}

static const MemoryRegionOps sifive_plic_ops = {
.read = sifive_plic_read,
.write = sifive_plic_write,
.endianness = DEVICE_LITTLE_ENDIAN,
.impl.min_access_size = 4,
.valid = {
.min_access_size = 4,
.max_access_size = 4
.min_access_size = 1,
.max_access_size = 4,
.accepts = sifive_plic_accepts,
}
};

Expand Down Expand Up @@ -387,7 +420,8 @@ static void sifive_plic_irq_request(void *opaque, int irq, int level)
}
sifive_plic_set_level(s, irq, !!level);
} else {
if (level > 0) {
sifive_plic_set_level(s, irq, !!level);
if (level > 0 && !sifive_plic_is_claimed(s, irq)) {
sifive_plic_set_pending(s, irq, true);
}
}
Expand Down
3 changes: 3 additions & 0 deletions hw/riscv/ot_earlgrey.c
Original file line number Diff line number Diff line change
Expand Up @@ -29,6 +29,7 @@
#include "qemu/typedefs.h"
#include "qapi/error.h"
#include "qom/object.h"
#include "exec/icount.h"
#include "hw/block/flash.h"
#include "hw/boards.h"
#include "hw/core/split-irq.h"
Expand Down Expand Up @@ -1588,6 +1589,8 @@ static void ot_eg_soc_ast_configure(DeviceState *dev, const IbexDeviceDef *def,
}

qdev_prop_set_string(dev, "topclocks", clock_cfg);
/* Align icount virtual clock frequency with the active AST main clock */
icount_set_freq_hz(!verilator_mode ? 24000000u : 500000u);
}

static void ot_eg_soc_dm_configure(DeviceState *dev, const IbexDeviceDef *def,
Expand Down
9 changes: 9 additions & 0 deletions include/exec/icount.h
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,15 @@ void icount_update(CPUState *cpu);
/* get raw icount value */
int64_t icount_get_raw(void);

/* get elapsed CPU cycles (executed instructions + idle warp cycles) */
int64_t icount_get_cycles(void);

/* set nominal CPU clock frequency in Hz for exact cycle-to-ns conversion */
void icount_set_freq_hz(uint64_t freq_hz);

/* advance icount_bias by delta_ns when sleeping for host I/O */
void icount_advance_bias_ns(int64_t delta_ns);

/* return the virtual CPU time in ns, based on the instruction counter. */
int64_t icount_get(void);
/*
Expand Down
Loading
Loading