Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static int kvmhv_read_guest_state_and_regs(struct kvm_vcpu *vcpu,
struct hv_guest_state *l2_hv,
struct pt_regs *l2_regs, u64 hv_ptr,
u64 regs_ptr) {
int size;
if (kvm_vcpu_read_guest(vc... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static int kvmhv_write_guest_state_and_regs(struct kvm_vcpu *vcpu,
struct hv_guest_state *l2_hv,
struct pt_regs *l2_regs, u64 hv_ptr,
u64 regs_ptr) {
int size;
size = hv_guest_state_... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | long kvmhv_set_partition_table(struct kvm_vcpu *vcpu) {
struct kvm *kvm = vcpu->kvm;
unsigned long ptcr = kvmppc_get_gpr(vcpu, 4);
int srcu_idx;
long ret = H_SUCCESS;
srcu_idx = srcu_read_lock(&kvm->srcu);
if ((ptcr & PRTS_MASK) + 12 - 4 > KVM_MAX_NESTED_GUESTS_SHIFT ||
!kvm_is_visible_gfn(vcpu->kvm... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static inline bool kvmhv_n_rmap_is_equal(u64 rmap_1, u64 rmap_2) {
return !((rmap_1 ^ rmap_2) & (RMAP_NESTED_LPID_MASK | RMAP_NESTED_GPA_MASK));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | static void kvmhv_update_nest_rmap_rc(struct kvm *kvm, u64 n_rmap,
unsigned long clr, unsigned long set,
unsigned long hpa, unsigned long mask) {
unsigned long gpa;
unsigned int shift, lpid;
pte_t *ptep;
gpa = n_rmap & RMAP_NESTED_GPA_... | [
0,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static void kvmhv_remove_nest_rmap_list(struct kvm *kvm, unsigned long *rmapp,
unsigned long hpa, unsigned long mask) {
struct llist_node *entry = llist_del_all((struct llist_head *)rmapp);
struct rmap_nested *cursor;
unsigned long rmap;
for_each_nest_rmap_safe(cursor, ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static inline int get_r(unsigned int instr) { return (instr >> 16) & 0x1; } | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static inline int get_lpid(unsigned long r_val) { return r_val & 0xffffffff; } | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | static void kvmhv_emulate_tlbie_lpid(struct kvm_vcpu *vcpu,
struct kvm_nested_guest *gp, int ric) {
struct kvm *kvm = vcpu->kvm;
mutex_lock(&gp->tlb_lock);
switch (ric) {
case 0:
spin_lock(&kvm->mmu_lock);
kvmppc_free_pgtable_radix(kvm, gp->shadow_pgtable, gp->shad... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | long kvmhv_do_nested_tlbie(struct kvm_vcpu *vcpu) {
int ret;
ret = kvmhv_emulate_priv_tlbie(vcpu, kvmppc_get_gpr(vcpu, 4),
kvmppc_get_gpr(vcpu, 5),
kvmppc_get_gpr(vcpu, 6));
if (ret)
return H_PARAMETER;
return H_SUCCESS;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static long do_tlb_invalidate_nested_tlb(struct kvm_vcpu *vcpu,
unsigned long lpid,
unsigned long pg_sizes,
unsigned long start,
unsigned long end) {
int... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | static long kvmhv_handle_nested_set_rc(struct kvm_vcpu *vcpu,
struct kvm_nested_guest *gp,
unsigned long n_gpa,
struct kvmppc_pte gpte,
unsigned long dsisr) {
str... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
static inline int kvmppc_radix_level_to_shift(int level) {
switch (level) {
case 2:
return PUD_SHIFT;
case 1:
return PMD_SHIFT;
default:
return PAGE_SHIFT;
}
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
int kvmhv_nested_next_lpid(struct kvm *kvm, int lpid) {
int ret = lpid + 1;
spin_lock(&kvm->mmu_lock);
if (!idr_get_next(&kvm->arch.kvm_nested_guest_idr, &ret))
ret = -1;
spin_unlock(&kvm->mmu_lock);
return ret;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c |
static void store_spr_state(struct kvm_vcpu *vcpu) {
vcpu->arch.tar = mfspr(SPRN_TAR);
#ifdef CONFIG_ALTIVEC
if (cpu_has_feature(CPU_FTR_ALTIVEC))
vcpu->arch.vrsave = mfspr(SPRN_VRSAVE);
#endif
if (vcpu->arch.hfscr & HFSCR_EBB) {
vcpu->arch.ebbhr = mfspr(SPRN_EBBHR);
vcpu->arch.ebbrr = mfspr(SPRN_E... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | void store_vcpu_state(struct kvm_vcpu *vcpu) {
store_spr_state(vcpu);
store_fp_state(&vcpu->arch.fp);
#ifdef CONFIG_ALTIVEC
store_vr_state(&vcpu->arch.vr);
#endif
#ifdef CONFIG_PPC_TRANSACTIONAL_MEM
if (cpu_has_feature(CPU_FTR_TM) || cpu_has_feature(CPU_FTR_P9_TM_HV_ASSIST)) {
unsigned long guest_msr = vc... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c |
static inline u64 mfslbe(unsigned int idx) {
u64 slbee;
asm volatile("slbmfee %0,%1" : "=r"(slbee) : "r"(idx));
return slbee;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | static void switch_mmu_to_host(struct kvm *kvm, u32 pid) {
u32 lpid = kvm->arch.host_lpid;
u64 lpcr = kvm->arch.host_lpcr;
asm volatile("hwsync" ::: "memory");
isync();
mtspr(SPRN_PID, pid);
mtspr(SPRN_LPID, lpid);
mtspr(SPRN_LPCR, lpcr);
/*
* isync is not required after the switch, because mtmsrd w... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | static void save_clear_host_mmu(struct kvm *kvm) {
if (!radix_enabled()) {
slb_clear_invalidate_partition();
}
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | static void save_clear_guest_mmu(struct kvm *kvm, struct kvm_vcpu *vcpu) {
if (kvm_is_radix(kvm)) {
radix_clear_slb();
} else {
int i;
int nr = 0;
for (i = 0; i < vcpu->arch.slb_nr; i++) {
u64 slbee, slbev;
slbee = mfslbe(i);
if (slbee & SLB_ESID_V) {
slbev = mfslbv(i);
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | static void flush_guest_tlb(struct kvm *kvm) {
unsigned long rb, set;
rb = PPC_BIT(52);
if (kvm_is_radix(kvm)) {
/* R=1 PRS=1 RIC=2 */
asm volatile(PPC_TLBIEL(% 0, % 4, % 3, % 2, % 1)
:
: "r"(rb), "i"(1), "i"(1), "i"(2), "r"(0)
: "memory");
for (set ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_p9_entry.c | static void check_need_tlb_flush(struct kvm *kvm, int pcpu,
struct kvm_nested_guest *nested) {
cpumask_t *need_tlb_flush;
bool all_set = true;
int i;
if (nested)
need_tlb_flush = &nested->need_tlb_flush;
else
need_tlb_flush = &kvm->arch.need_tlb_flush;
if (likely(!... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_ras.c | static void reload_slb(struct kvm_vcpu *vcpu) {
struct slb_shadow *slb;
unsigned long i, n;
asm volatile("slbmte %0,%0; slbia" : : "r"(0));
/* Do they have an SLB shadow buffer registered? */
slb = vcpu->arch.slb_shadow.pinned_addr;
if (!slb)
return;
/* Sanity check */
n = min_t(u32, be32_to_cpu(... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_ras.c | long kvmppc_p9_realmode_hmi_handler(struct kvm_vcpu *vcpu) {
struct kvmppc_vcore *vc = vcpu->arch.vcore;
long ret = 0;
if (vc->tb_offset_applied) {
u64 new_tb = mftb() - vc->tb_offset_applied;
mtspr(SPRN_TBU40, new_tb);
if ((mftb() & 0xffffff) < (new_tb & 0xffffff)) {
new_tb += 0x1000000;
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_ras.c |
static bool kvmppc_tb_resync_required(void) {
if (test_and_set_bit(CORE_TB_RESYNC_REQ_BIT,
&local_paca->sibling_subcore_state->flags))
return false;
return true;
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_ras.c | long kvmppc_realmode_hmi_handler(void) {
bool resync_req;
local_paca->hmi_irqs++;
if (hmi_handle_debugtrig(NULL) >= 0)
return 1;
resync_req = kvmppc_tb_resync_required();
/* Reset the subcore status to indicate it has exited guest */
kvmppc_subcore_exit_guest();
/*
* Wait for other subcores on... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c | void kvmppc_add_revmap_chain(struct kvm *kvm, struct revmap_entry *rev,
unsigned long *rmap, long pte_index,
int realmode) {
struct revmap_entry *head, *tail;
unsigned long i;
if (*rmap & KVMPPC_RMAP_PRESENT) {
i = *rmap & KVMPPC_RMAP_INDEX;
head ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c | static unsigned long *revmap_for_hpte(struct kvm *kvm, unsigned long hpte_v,
unsigned long hpte_gr,
struct kvm_memory_slot **memslotp,
unsigned long *gfnp) {
struct kvm_memory_slot *memslot;
unsigned lo... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c |
long kvmppc_h_enter(struct kvm_vcpu *vcpu, unsigned long flags, long pte_index,
unsigned long pteh, unsigned long ptel) {
return kvmppc_do_h_enter(vcpu->kvm, flags, pte_index, pteh, ptel,
vcpu->arch.pgdir, true, &vcpu->arch.regs.gpr[4]);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c |
static inline int is_mmio_hpte(unsigned long v, unsigned long r) {
return ((v & HPTE_V_ABSENT) && (r & (HPTE_R_KEY_HI | HPTE_R_KEY_LO)) ==
(HPTE_R_KEY_HI | HPTE_R_KEY_LO));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c | static int kvmppc_get_hpa(struct kvm_vcpu *vcpu, unsigned long mmu_seq,
unsigned long gpa, int writing, unsigned long *hpa,
struct kvm_memory_slot **memslot_p) {
struct kvm *kvm = vcpu->kvm;
struct kvm_memory_slot *memslot;
unsigned long gfn, hva, pa, psize = PA... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_mmu.c |
static struct mmio_hpte_cache_entry *mmio_cache_search(struct kvm_vcpu *vcpu,
unsigned long eaddr,
unsigned long slb_v,
long mmio_update) {
struct mmio_... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static void ics_rm_check_resend(struct kvmppc_xics *xics,
struct kvmppc_ics *ics,
struct kvmppc_icp *icp) {
int i;
for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
struct ics_irq_state *state = &ics->irq_state[i];
if (state->resend)
icp_r... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c |
static inline int find_available_hostcore(int action) {
int core;
int my_core = smp_processor_id() >> threads_shift;
struct kvmppc_host_rm_core *rm_core = kvmppc_host_rm_ops_hv->rm_core;
core = grab_next_hostcore(my_core, rm_core, cpu_nr_cores(), action);
if (core == -1)
core = grab_next_hostcore(core, ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static void icp_rm_check_resend(struct kvmppc_xics *xics,
struct kvmppc_icp *icp) {
u32 icsid;
smp_rmb();
for_each_set_bit(icsid, icp->resend_map, xics->max_icsid + 1) {
struct kvmppc_ics *ics = xics->ics[icsid];
if (!test_and_clear_bit(icsid, icp->resend_map))
cont... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static void icp_rm_down_cppr(struct kvmppc_xics *xics, struct kvmppc_icp *icp,
u8 new_cppr) {
union kvmppc_icp_state old_state, new_state;
bool resend;
do {
old_state = new_state = READ_ONCE(icp->state);
/* Down_CPPR */
new_state.cppr = new_cppr;
/*
* Cut down ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static int ics_rm_eoi(struct kvm_vcpu *vcpu, u32 irq) {
struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
struct kvmppc_icp *icp = vcpu->arch.icp;
struct kvmppc_ics *ics;
struct ics_irq_state *state;
u16 src;
u32 pq_old, pq_new;
ics = kvmppc_xics_find_ics(xics, irq, &src);
if (!ics)
goto bail;
st... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static inline void this_cpu_inc_rm(unsigned int __percpu *addr) {
unsigned long l;
unsigned int *raddr;
int cpu = smp_processor_id();
raddr = per_cpu_ptr(addr, cpu);
l = (unsigned long)raddr;
if (get_region_id(l) == VMALLOC_REGION_ID) {
l = vmalloc_to_phys(raddr);
raddr = (unsigned int *)l;
}
... | [
0,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_rm_xics.c | static void kvmppc_rm_handle_irq_desc(struct irq_desc *desc) {
this_cpu_inc_rm(desc->kstat_irqs);
__this_cpu_inc(kstat.irqs_sum);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_tm.c | static void emulate_tx_failure(struct kvm_vcpu *vcpu, u64 failure_cause) {
u64 texasr, tfiar;
u64 msr = vcpu->arch.shregs.msr;
tfiar = vcpu->arch.regs.nip & ~0x3ull;
texasr = (failure_cause << 56) | TEXASR_ABORT | TEXASR_FS | TEXASR_EXACT;
if (MSR_TM_SUSPENDED(vcpu->arch.shregs.msr))
texasr |= TEXASR_SUS... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_tm_builtin.c | void kvmhv_emulate_tm_rollback(struct kvm_vcpu *vcpu) {
vcpu->arch.shregs.msr &= ~MSR_TS_MASK;
vcpu->arch.regs.nip = vcpu->arch.tfhar;
copy_from_checkpoint(vcpu);
vcpu->arch.regs.ccr = (vcpu->arch.regs.ccr & 0x0fffffff) | 0xa0000000;
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | void kvmppc_uvmem_slot_free(struct kvm *kvm,
const struct kvm_memory_slot *slot) {
struct kvmppc_uvmem_slot *p, *next;
mutex_lock(&kvm->arch.uvmem_lock);
list_for_each_entry_safe(p, next, &kvm->arch.uvmem_pfns, list) {
if (p->base_pfn == slot->base_gfn) {
vfree(p->pfns);
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | static void kvmppc_gfn_remove(unsigned long gfn, struct kvm *kvm) {
kvmppc_mark_gfn(gfn, kvm, 0, 0);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | static bool
kvmppc_next_nontransitioned_gfn(const struct kvm_memory_slot *memslot,
struct kvm *kvm, unsigned long *gfn) {
struct kvmppc_uvmem_slot *p = NULL, *iter;
bool ret = false;
unsigned long i;
list_for_each_entry(iter, &kvm->arch.uvmem_pfns,
list) if... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | unsigned long kvmppc_h_svm_init_start(struct kvm *kvm) {
struct kvm_memslots *slots;
struct kvm_memory_slot *memslot, *m;
int ret = H_SUCCESS;
int srcu_idx, bkt;
kvm->arch.secure_guest = KVMPPC_SECURE_INIT_START;
if (!kvmppc_uvmem_bitmap)
return H_UNSUPPORTED;
if (!kvm_is_radix(kvm))
return H_U... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | unsigned long kvmppc_h_svm_init_abort(struct kvm *kvm) {
int srcu_idx, bkt;
struct kvm_memory_slot *memslot;
if (!(kvm->arch.secure_guest & KVMPPC_SECURE_INIT_START))
return H_UNSUPPORTED;
if (kvm->arch.secure_guest & KVMPPC_SECURE_INIT_DONE)
return H_STATE;
srcu_idx = srcu_read_lock(&kvm->srcu);
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | unsigned long kvmppc_h_svm_init_done(struct kvm *kvm) {
struct kvm_memslots *slots;
struct kvm_memory_slot *memslot;
int srcu_idx, bkt;
long ret = H_SUCCESS;
if (!(kvm->arch.secure_guest & KVMPPC_SECURE_INIT_START))
return H_UNSUPPORTED;
srcu_idx = srcu_read_lock(&kvm->srcu);
slots = kvm_memslots(kv... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | unsigned long kvmppc_h_svm_page_out(struct kvm *kvm, unsigned long gpa,
unsigned long flags,
unsigned long page_shift) {
unsigned long gfn = gpa >> page_shift;
unsigned long start, end;
struct vm_area_struct *vma;
int srcu_idx;
int ret;
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c |
int kvmppc_uvmem_memslot_create(struct kvm *kvm,
const struct kvm_memory_slot *new) {
int ret = __kvmppc_uvmem_memslot_create(kvm, new);
if (!ret)
ret = kvmppc_uv_migrate_mem_slot(kvm, new);
return ret;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c |
void kvmppc_uvmem_memslot_delete(struct kvm *kvm,
const struct kvm_memory_slot *old) {
__kvmppc_uvmem_memslot_delete(kvm, old);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c | int kvmppc_uvmem_init(void) {
int ret = 0;
unsigned long size;
struct resource *res;
void *addr;
unsigned long pfn_last, pfn_first;
size = kvmppc_get_secmem_size();
if (!size) {
pr_info("KVMPPC-UVMEM: No support for secure guests\n");
goto out;
}
res = request_free_mem_region(&iomem_resourc... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_uvmem.c |
void kvmppc_uvmem_free(void) {
if (!kvmppc_uvmem_bitmap)
return;
memunmap_pages(&kvmppc_uvmem_pgmap);
release_mem_region(kvmppc_uvmem_pgmap.range.start,
range_len(&kvmppc_uvmem_pgmap.range));
kfree(kvmppc_uvmem_bitmap);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_mmu_hpte.c | static inline u64 kvmppc_mmu_hash_vpte_64k(u64 vpage) {
return hash_64((vpage & 0xffffffff0ULL) >> 4, HPTEG_HASH_BITS_VPTE_64K);
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_mmu_hpte.c | static void kvmppc_mmu_pte_vflush_short(struct kvm_vcpu *vcpu, u64 guest_vp) {
struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu);
struct hlist_head *list;
struct hpte_cache *pte;
u64 vp_mask = 0xfffffffffULL;
list = &vcpu3s->hpte_hash_vpte[kvmppc_mmu_hash_vpte(guest_vp)];
rcu_read_lock();
hlist_for_e... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_mmu_hpte.c |
void kvmppc_mmu_pte_pflush(struct kvm_vcpu *vcpu, ulong pa_start,
ulong pa_end) {
struct kvmppc_vcpu_book3s *vcpu3s = to_book3s(vcpu);
struct hpte_cache *pte;
int i;
trace_kvm_book3s_mmu_flush("p", vcpu, pa_start, pa_end);
rcu_read_lock();
for (i = 0; i < HPTEG_HASH_NUM_VPTE_L... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_paired_singles.c | static int kvmppc_emulate_fpr_load(struct kvm_vcpu *vcpu, int rs, ulong addr,
int ls_type) {
int emulated = EMULATE_FAIL;
int r;
char tmp[8];
int len = sizeof(u32);
if (ls_type == FPU_LS_DOUBLE)
len = sizeof(u64);
r = kvmppc_ld(vcpu, &addr, len, tmp, true);
vcpu->a... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_paired_singles.c |
static int kvmppc_emulate_fpr_store(struct kvm_vcpu *vcpu, int rs, ulong addr,
int ls_type) {
int emulated = EMULATE_FAIL;
int r;
char tmp[8];
u64 val;
int len;
switch (ls_type) {
case FPU_LS_SINGLE:
kvm_cvt_df(&VCPU_FPR(vcpu, rs), (u32 *)tmp);
val = *((u32 *)... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_paired_singles.c |
static int get_d_signext(u32 inst) {
int d = inst & 0x8ff;
if (d & 0x800)
return -(d & 0x7ff);
return (d & 0x7ff);
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_paired_singles.c | static int kvmppc_ps_two_in(struct kvm_vcpu *vcpu, bool rc, int reg_out,
int reg_in1, int reg_in2, int scalar,
void (*func)(u64 *fpscr, u32 *dst, u32 *src1,
u32 *src2)) {
u32 *qpr = vcpu->arch.qpr;
u32 ps0_out;
u32 ps... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c |
static void kvmppc_unfixup_split_real(struct kvm_vcpu *vcpu) {
if (vcpu->arch.hflags & BOOK3S_HFLAG_SPLIT_HACK) {
ulong pc = kvmppc_get_pc(vcpu);
ulong lr = kvmppc_get_lr(vcpu);
if ((pc & SPLIT_HACK_MASK) == SPLIT_HACK_OFFS)
kvmppc_set_pc(vcpu, pc & ~SPLIT_HACK_MASK);
if ((lr & SPLIT_HACK_MASK)... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static void kvmppc_inject_interrupt_pr(struct kvm_vcpu *vcpu, int vec,
u64 srr1_flags) {
unsigned long msr, pc, new_msr, new_pc;
kvmppc_unfixup_split_real(vcpu);
msr = kvmppc_get_msr(vcpu);
pc = kvmppc_get_pc(vcpu);
new_msr = vcpu->arch.intr_msr;
new_pc = to_book3s(v... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static void kvmppc_core_vcpu_put_pr(struct kvm_vcpu *vcpu) {
#ifdef CONFIG_PPC_BOOK3S_64
struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
if (svcpu->in_use) {
kvmppc_copy_from_svcpu(vcpu);
}
memcpy(to_book3s(vcpu)->slb_shadow, svcpu->slb, sizeof(svcpu->slb));
to_book3s(vcpu)->slb_shadow_max = sv... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static void kvmppc_handle_lost_math_exts(struct kvm_vcpu *vcpu) {
ulong exit_nr;
ulong ext_diff = (kvmppc_get_msr(vcpu) & ~vcpu->arch.guest_owned_ext) &
(MSR_FP | MSR_VEC | MSR_VSX);
if (!ext_diff)
return;
if (ext_diff == MSR_FP)
exit_nr = BOOK3S_INTERRUPT_FP_UNAVAIL;
else if (ext... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c |
void kvmppc_restore_tm_pr(struct kvm_vcpu *vcpu) {
if (!MSR_TM_ACTIVE(kvmppc_get_msr(vcpu))) {
kvmppc_restore_tm_sprs(vcpu);
if (kvmppc_get_msr(vcpu) & MSR_TM) {
kvmppc_handle_lost_math_exts(vcpu);
if (vcpu->arch.fscr & FSCR_TAR)
kvmppc_handle_fac(vcpu, FSCR_TAR_LG);
}
return;
}... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static int kvmppc_core_check_requests_pr(struct kvm_vcpu *vcpu) {
int r = 1;
/* We misuse TLB_FLUSH to indicate that we want to clear
all shadow cache entries */
if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu))
kvmppc_mmu_pte_flush(vcpu, 0, 0);
return r;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static bool do_kvm_unmap_gfn(struct kvm *kvm, struct kvm_gfn_range *range) {
unsigned long i;
struct kvm_vcpu *vcpu;
kvm_for_each_vcpu(i, vcpu, kvm) kvmppc_mmu_pte_pflush(
vcpu, range->start << PAGE_SHIFT, range->end << PAGE_SHIFT);
return false;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static bool kvm_age_gfn_pr(struct kvm *kvm, struct kvm_gfn_range *range) {
/* XXX could be more clever ;) */
return false;
} | [
0,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static bool kvm_set_spte_gfn_pr(struct kvm *kvm, struct kvm_gfn_range *range) {
return do_kvm_unmap_gfn(kvm, range);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c |
static bool kvmppc_visible_gpa(struct kvm_vcpu *vcpu, gpa_t gpa) {
ulong mp_pa = vcpu->arch.magic_page_pa;
if (!(kvmppc_get_msr(vcpu) & MSR_SF))
mp_pa = (uint32_t)mp_pa;
gpa &= ~0xFFFULL;
if (unlikely(mp_pa) && unlikely((mp_pa & KVM_PAM) == (gpa & KVM_PAM))) {
return true;
}
return kvm_is_visibl... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static void kvmppc_emulate_fac(struct kvm_vcpu *vcpu, ulong fac) {
enum emulation_result er = EMULATE_FAIL;
if (!(kvmppc_get_msr(vcpu) & MSR_PR))
er = kvmppc_emulate_instruction(vcpu);
if ((er != EMULATE_DONE) && (er != EMULATE_AGAIN)) {
kvmppc_trigger_fac_interrupt(vcpu, fac);
}
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static int kvm_vm_ioctl_get_dirty_log_pr(struct kvm *kvm,
struct kvm_dirty_log *log) {
struct kvm_memory_slot *memslot;
struct kvm_vcpu *vcpu;
ulong ga, ga_end;
int is_dirty = 0;
int r;
unsigned long n;
mutex_lock(&kvm->slots_lock);
r = kvm_get_dirty_log(kvm, l... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static int kvm_configure_mmu_pr(struct kvm *kvm,
struct kvm_ppc_mmuv3_cfg *cfg) {
if (!cpu_has_feature(CPU_FTR_ARCH_300))
return -ENODEV;
if (cfg->flags || cfg->process_table)
return -EINVAL;
return 0;
}
#else | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr.c | static int kvmppc_core_check_processor_compat_pr(void) {
if (cpu_has_feature(CPU_FTR_ARCH_300) && radix_enabled())
return -EIO;
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr_papr.c |
static int kvmppc_h_pr_stuff_tce(struct kvm_vcpu *vcpu) {
unsigned long liobn = kvmppc_get_gpr(vcpu, 4);
unsigned long ioba = kvmppc_get_gpr(vcpu, 5);
unsigned long tce_value = kvmppc_get_gpr(vcpu, 6);
unsigned long npages = kvmppc_get_gpr(vcpu, 7);
long rc;
rc = kvmppc_h_stuff_tce(vcpu, liobn, ioba, tce_... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_pr_papr.c |
static int kvmppc_h_pr_xics_hcall(struct kvm_vcpu *vcpu, u32 cmd) {
long rc = kvmppc_xics_hcall(vcpu, cmd);
kvmppc_set_gpr(vcpu, 3, rc);
return EMULATE_DONE;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_rtas.c | static void kvm_rtas_set_xive(struct kvm_vcpu *vcpu, struct rtas_args *args) {
u32 irq, server, priority;
int rc;
if (be32_to_cpu(args->nargs) != 3 || be32_to_cpu(args->nret) != 1) {
rc = -3;
goto out;
}
irq = be32_to_cpu(args->args[0]);
server = be32_to_cpu(args->args[1]);
priority = be32_to_cp... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_rtas.c |
static void kvm_rtas_int_off(struct kvm_vcpu *vcpu, struct rtas_args *args) {
u32 irq;
int rc;
if (be32_to_cpu(args->nargs) != 1 || be32_to_cpu(args->nret) != 1) {
rc = -3;
goto out;
}
irq = be32_to_cpu(args->args[0]);
if (xics_on_xive())
rc = kvmppc_xive_int_off(vcpu->kvm, irq);
else
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_rtas.c |
static int rtas_token_define(struct kvm *kvm, char *name, u64 token) {
struct rtas_token_definition *d;
struct rtas_handler *h = NULL;
bool found;
int i;
lockdep_assert_held(&kvm->arch.rtas_token_lock);
list_for_each_entry(d, &kvm->arch.rtas_tokens, list) {
if (d->token == token)
return -EEXIST... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
static bool write_xive(struct kvmppc_xics *xics, struct kvmppc_ics *ics,
struct ics_irq_state *state, u32 server, u32 priority,
u32 saved_priority) {
bool deliver;
unsigned long flags;
local_irq_save(flags);
arch_spin_lock(&ics->lock);
state->server = server;
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static inline bool icp_try_update(struct kvmppc_icp *icp,
union kvmppc_icp_state old,
union kvmppc_icp_state new,
bool change_self) {
bool success;
new.out_ee = (new.xisr && (new.pending_pri < new.cppr));
/* At... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static void icp_check_resend(struct kvmppc_xics *xics, struct kvmppc_icp *icp) {
u32 icsid;
smp_rmb();
for_each_set_bit(icsid, icp->resend_map, xics->max_icsid + 1) {
struct kvmppc_ics *ics = xics->ics[icsid];
if (!test_and_clear_bit(icsid, icp->resend_map))
continue;
if (!ics)
continue;... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
static int kvmppc_h_ipoll(struct kvm_vcpu *vcpu, unsigned long server) {
union kvmppc_icp_state state;
struct kvmppc_icp *icp;
icp = vcpu->arch.icp;
if (icp->server_num != server) {
icp = kvmppc_xics_find_server(vcpu->kvm, server);
if (!icp)
return H_PARAMETER;
}
state = READ_ONCE(icp->state... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static noinline int kvmppc_h_eoi(struct kvm_vcpu *vcpu, unsigned long xirr) {
struct kvmppc_xics *xics = vcpu->kvm->arch.xics;
struct kvmppc_icp *icp = vcpu->arch.icp;
u32 irq = xirr & 0x00ffffff;
XICS_DBG("h_eoi vcpu %d eoi %#lx\n", vcpu->vcpu_id, xirr);
icp_down_cppr(xics, icp, xirr >> 24);
/* IPIs hav... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static void xics_debugfs_irqmap(struct seq_file *m,
struct kvmppc_passthru_irqmap *pimap) {
int i;
if (!pimap)
return;
seq_printf(m, "========\nPIRQ mappings: %d maps\n===========\n",
pimap->n_mapped);
for (i = 0; i < pimap->n_mapped; i++) {
seq_printf(m, "r... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
static void xics_debugfs_init(struct kvmppc_xics *xics) {
xics->dentry = debugfs_create_file("xics", 0444, xics->kvm->debugfs_dentry,
xics, &xics_debug_fops);
pr_debug("%s: created\n", __func__);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static struct kvmppc_ics *
kvmppc_xics_create_ics(struct kvm *kvm, struct kvmppc_xics *xics, int irq) {
struct kvmppc_ics *ics;
int i, icsid;
icsid = irq >> KVMPPC_XICS_ICS_SHIFT;
mutex_lock(&kvm->lock);
if (xics->ics[icsid])
goto out;
/* Create the ICS */
ics = kzalloc(sizeof(struct kvmppc_ics), ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
u64 kvmppc_xics_get_icp(struct kvm_vcpu *vcpu) {
struct kvmppc_icp *icp = vcpu->arch.icp;
union kvmppc_icp_state state;
if (!icp)
return 0;
state = icp->state;
return ((u64)state.cppr << KVM_REG_PPC_ICP_CPPR_SHIFT) |
((u64)state.xisr << KVM_REG_PPC_ICP_XISR_SHIFT) |
((u64)state.mfrr <<... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
static int xics_get_source(struct kvmppc_xics *xics, long irq, u64 addr) {
int ret;
struct kvmppc_ics *ics;
struct ics_irq_state *irqp;
u64 __user *ubufp = (u64 __user *)addr;
u16 idx;
u64 val, prio;
unsigned long flags;
ics = kvmppc_xics_find_ics(xics, irq, &idx);
if (!ics)
return -ENOENT;
i... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static int xics_set_source(struct kvmppc_xics *xics, long irq, u64 addr) {
struct kvmppc_ics *ics;
struct ics_irq_state *irqp;
u64 __user *ubufp = (u64 __user *)addr;
u16 idx;
u64 val;
u8 prio;
u32 server;
unsigned long flags;
if (irq < KVMPPC_XICS_FIRST_IRQ || irq >= KVMPPC_XICS_NR_IRQS)
return ... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
int kvmppc_xics_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
bool line_status) {
struct kvmppc_xics *xics = kvm->arch.xics;
if (!xics)
return -ENODEV;
return ics_deliver_irq(xics, irq, level);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c | static void kvmppc_xics_release(struct kvm_device *dev) {
struct kvmppc_xics *xics = dev->private;
unsigned long i;
struct kvm *kvm = xics->kvm;
struct kvm_vcpu *vcpu;
pr_devel("Releasing xics device\n");
debugfs_remove(xics->dentry);
/*
* We should clean up the vCPU interrupt presenters first.
*... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.c |
static void kvmppc_xics_init(struct kvm_device *dev) {
struct kvmppc_xics *xics = dev->private;
xics_debugfs_init(xics);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xics.h |
static inline struct kvmppc_icp *kvmppc_xics_find_server(struct kvm *kvm,
u32 nr) {
struct kvm_vcpu *vcpu = NULL;
unsigned long i;
kvm_for_each_vcpu(i, vcpu, kvm) {
if (vcpu->arch.icp && nr == vcpu->arch.icp->server_num)
return vcpu->arch.icp;
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | static unsigned long xive_vm_h_xirr(struct kvm_vcpu *vcpu) {
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
u8 old_cppr;
u32 hirq;
pr_devel("H_XIRR\n");
xc->stat_vm_h_xirr++;
xive_vm_ack_pending(xc);
pr_devel(" new pending=0x%02x hw_cppr=%d cppr=%d\n", xc->pending, xc->hw_cppr,
xc->cpp... | [
0,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | static int xive_vm_h_ipi(struct kvm_vcpu *vcpu, unsigned long server,
unsigned long mfrr) {
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
pr_devel("H_IPI(server=%08lx,mfrr=%ld)\n", server, mfrr);
xc->stat_vm_h_ipi++;
vcpu = kvmppc_xive_find_server(vcpu->kvm, server);
if (!vcp... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | bool kvmppc_xive_rearm_escalation(struct kvm_vcpu *vcpu) {
void __iomem *esc_vaddr = (void __iomem *)vcpu->arch.xive_esc_vaddr;
bool ret = true;
if (!esc_vaddr)
return ret;
if (vcpu->arch.xive_esc_on) {
/*
* If we still have a pending escalation, abort the cede,
* and we must set PQ to 10 ra... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | static int xive_try_pick_queue(struct kvm_vcpu *vcpu, u8 prio) {
struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
struct xive_q *q;
u32 max;
if (WARN_ON(!xc))
return -ENXIO;
if (!xc->valid)
return -ENXIO;
q = &xc->queues[prio];
if (WARN_ON(!q->qpage))
return -ENXIO;
max = (q->msk + 1) ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | int kvmppc_xive_select_target(struct kvm *kvm, u32 *server, u8 prio) {
struct kvm_vcpu *vcpu;
unsigned long i;
int rc;
vcpu = kvmppc_xive_find_server(kvm, *server);
if (!vcpu) {
pr_devel("Can't find server %d\n", *server);
return -EINVAL;
}
pr_devel("Finding irq target on 0x%x/%d...\n", *server,... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | static u8 xive_lock_and_mask(struct kvmppc_xive *xive,
struct kvmppc_xive_src_block *sb,
struct kvmppc_xive_irq_state *state) {
struct xive_irq_data *xd;
u32 hw_num;
u8 old_prio;
u64 val;
for (;;) {
arch_spin_lock(&sb->lock);
old_prio = state-... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_xive.c | static void xive_lock_for_unmask(struct kvmppc_xive_src_block *sb,
struct kvmppc_xive_irq_state *state) {
for (;;) {
arch_spin_lock(&sb->lock);
if (!state->in_eoi)
break;
arch_spin_unlock(&sb->lock);
}
} | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.