Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
Linux Kernel | arch/powerpc/kvm/book3s.c |
bool kvm_test_age_gfn(struct kvm *kvm, struct kvm_gfn_range *range) {
return kvm->arch.kvm_ops->test_age_gfn(kvm, range);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvmppc_h_logical_ci_load(struct kvm_vcpu *vcpu) {
unsigned long size = kvmppc_get_gpr(vcpu, 4);
unsigned long addr = kvmppc_get_gpr(vcpu, 5);
u64 buf;
int srcu_idx;
int ret;
if (!is_power_of_2(size) || (size > sizeof(buf)))
return H_TOO_HARD;
srcu_idx = srcu_read_lock(&vcpu->kvm->srcu);
ret =... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c | int kvmppc_core_check_processor_compat(void) { return 0; } | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvmppc_book3s_hcall_implemented(struct kvm *kvm, unsigned long hcall) {
return kvm->arch.kvm_ops->hcall_implemented(hcall);
}
#ifdef CONFIG_KVM_XICS | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c | int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
bool line_status) {
if (xics_on_xive())
return kvmppc_xive_set_irq(kvm, irq_source_id, irq, level, line_status);
else
return kvmppc_xics_set_irq(kvm, irq_source_id, irq, level, line_status);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s.c |
int kvm_arch_set_irq_inatomic(struct kvm_kernel_irq_routing_entry *irq_entry,
struct kvm *kvm, int irq_source_id, int level,
bool line_status) {
return kvm_set_irq(kvm, irq_source_id, irq_entry->gsi, level, line_status);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu.c |
static inline bool sr_ks(u32 sr_raw) {
return (sr_raw & 0x40000000) ? true : false;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu.c |
static u32 find_sr(struct kvm_vcpu *vcpu, gva_t eaddr) {
return kvmppc_get_sr(vcpu, (eaddr >> 28) & 0xf);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu.c |
static void kvmppc_mmu_book3s_32_mtsrin(struct kvm_vcpu *vcpu, u32 srnum,
ulong value) {
kvmppc_set_sr(vcpu, srnum, value);
kvmppc_mmu_map_segment(vcpu, srnum << SID_SHIFT);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu.c |
static bool kvmppc_mmu_book3s_32_is_dcbz32(struct kvm_vcpu *vcpu) {
return true;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu_host.c |
static u32 *kvmppc_mmu_get_pteg(struct kvm_vcpu *vcpu, u32 vsid, u32 eaddr,
bool primary) {
u32 page, hash;
ulong pteg = htab;
page = (eaddr & ~ESID_MASK) >> 12;
hash = ((vsid ^ page) << 6);
if (!primary)
hash = ~hash;
hash &= htabmask;
pteg |= hash;
dprintk_mmu... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_32_mmu_host.c |
void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu) {
int i;
struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
dprintk_sr("MMU: flushing all segments (%d)\n", ARRAY_SIZE(svcpu->sr));
for (i = 0; i < ARRAY_SIZE(svcpu->sr); i++)
svcpu->sr[i] = SR_INVALID;
svcpu_put(svcpu);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static struct kvmppc_slb *kvmppc_mmu_book3s_64_find_slbe(struct kvm_vcpu *vcpu,
gva_t eaddr) {
int i;
u64 esid = GET_ESID(eaddr);
u64 esid_1t = GET_ESID_1T(eaddr);
for (i = 0; i < vcpu->arch.slb_nr; i++) {
u64 cmp_esid = esid;
if (!vcpu->arch.s... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static u64 kvmppc_slb_calc_vpn(struct kvmppc_slb *slb, gva_t eaddr) {
eaddr &= kvmppc_slb_offset_mask(slb);
return (eaddr >> VPN_SHIFT) |
((slb->vsid) << (kvmppc_slb_sid_shift(slb) - VPN_SHIFT));
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static u64 kvmppc_mmu_book3s_64_ea_to_vp(struct kvm_vcpu *vcpu, gva_t eaddr,
bool data) {
struct kvmppc_slb *slb;
slb = kvmppc_mmu_book3s_64_find_slbe(vcpu, eaddr);
if (!slb)
return 0;
return kvmppc_slb_calc_vpn(slb, eaddr);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static int mmu_pagesize(int mmu_pg) {
switch (mmu_pg) {
case MMU_PAGE_64K:
return 16;
case MMU_PAGE_16M:
return 24;
}
return 12;
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static int kvmppc_mmu_book3s_64_get_pagesize(struct kvmppc_slb *slbe) {
return mmu_pagesize(slbe->base_page_size);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static u32 kvmppc_mmu_book3s_64_get_page(struct kvmppc_slb *slbe, gva_t eaddr) {
int p = kvmppc_mmu_book3s_64_get_pagesize(slbe);
return ((eaddr & kvmppc_slb_offset_mask(slbe)) >> p);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c |
static int kvmppc_mmu_book3s_64_slbfee(struct kvm_vcpu *vcpu, gva_t eaddr,
ulong *ret_slb) {
struct kvmppc_slb *slbe = kvmppc_mmu_book3s_64_find_slbe(vcpu, eaddr);
if (slbe) {
*ret_slb = slbe->origv;
return 0;
}
*ret_slb = 0;
return -ENOENT;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu.c | static int segment_contains_magic_page(struct kvm_vcpu *vcpu, ulong esid) {
ulong mp_ea = vcpu->arch.magic_page_ea;
return mp_ea && !(kvmppc_get_msr(vcpu) & MSR_PR) &&
(mp_ea >> SID_SHIFT) == esid;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_host.c |
void kvmppc_mmu_invalidate_pte(struct kvm_vcpu *vcpu, struct hpte_cache *pte) {
mmu_hash_ops.hpte_invalidate(pte->slot, pte->host_vpn, pte->pagesize,
pte->pagesize, MMU_SEGSIZE_256M, false);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_host.c |
static struct kvmppc_sid_map *find_sid_vsid(struct kvm_vcpu *vcpu, u64 gvsid) {
struct kvmppc_sid_map *map;
u16 sid_map_mask;
if (kvmppc_get_msr(vcpu) & MSR_PR)
gvsid |= VSID_PR;
sid_map_mask = kvmppc_sid_hash(vcpu, gvsid);
map = &to_book3s(vcpu)->sid_map[sid_map_mask];
if (map->valid && (map->guest... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_host.c | int kvmppc_mmu_map_segment(struct kvm_vcpu *vcpu, ulong eaddr) {
struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
u64 esid = eaddr >> SID_SHIFT;
u64 slb_esid = (eaddr & ESID_MASK) | SLB_ESID_V;
u64 slb_vsid = SLB_VSID_USER;
u64 gvsid;
int slb_index;
struct kvmppc_sid_map *map;
int r = 0;
sl... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_host.c | void kvmppc_mmu_flush_segment(struct kvm_vcpu *vcpu, ulong ea, ulong seg_size) {
struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
ulong seg_mask = -seg_size;
int i;
for (i = 0; i < svcpu->slb_max; i++) {
if ((svcpu->slb[i].esid & SLB_ESID_V) &&
(svcpu->slb[i].esid & seg_mask) == ea) {
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_host.c |
void kvmppc_mmu_flush_segments(struct kvm_vcpu *vcpu) {
struct kvmppc_book3s_shadow_vcpu *svcpu = svcpu_get(vcpu);
svcpu->slb_max = 0;
svcpu->slb[0].esid = 0;
svcpu_put(svcpu);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | int kvmppc_allocate_hpt(struct kvm_hpt_info *info, u32 order) {
unsigned long hpt = 0;
int cma = 0;
struct page *page = NULL;
struct revmap_entry *rev;
unsigned long npte;
if ((order < PPC_MIN_HPT_ORDER) || (order > PPC_MAX_HPT_ORDER))
return -EINVAL;
page = kvm_alloc_hpt_cma(1ul << (order - PAGE_SH... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | static inline unsigned long hpte0_pgsize_encoding(unsigned long pgsize) {
return (pgsize > 0x1000) ? HPTE_V_LARGE : 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | static void kvmppc_unmap_hpte(struct kvm *kvm, unsigned long i,
struct kvm_memory_slot *memslot,
unsigned long *rmapp, unsigned long gfn) {
__be64 *hptep = (__be64 *)(kvm->arch.hpt.virt + (i << 4));
struct revmap_entry *rev = kvm->arch.hpt.rev;
unsigned ... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c |
bool kvm_age_gfn_hv(struct kvm *kvm, struct kvm_gfn_range *range) {
gfn_t gfn;
bool ret = false;
if (kvm_is_radix(kvm)) {
for (gfn = range->start; gfn < range->end; gfn++)
ret |= kvm_age_radix(kvm, range->slot, gfn);
} else {
for (gfn = range->start; gfn < range->end; gfn++)
ret |= kvm_age... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c |
bool kvm_test_age_gfn_hv(struct kvm *kvm, struct kvm_gfn_range *range) {
WARN_ON(range->start + 1 != range->end);
if (kvm_is_radix(kvm))
return kvm_test_age_radix(kvm, range->slot, range->start);
else
return kvm_test_age_rmapp(kvm, range->slot, range->start);
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | void kvmppc_unpin_guest_page(struct kvm *kvm, void *va, unsigned long gpa,
bool dirty) {
struct page *page = virt_to_page(va);
struct kvm_memory_slot *memslot;
unsigned long gfn;
int srcu_idx;
put_page(page);
if (!dirty)
return;
gfn = gpa >> PAGE_SHIFT;
srcu_idx = src... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | long kvm_vm_ioctl_resize_hpt_commit(struct kvm *kvm,
struct kvm_ppc_resize_hpt *rhpt) {
unsigned long flags = rhpt->flags;
unsigned long shift = rhpt->shift;
struct kvm_resize_hpt *resize;
long ret;
if (flags != 0 || kvm_is_radix(kvm))
return -EINVAL;
if (shift && (... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c | int kvm_vm_ioctl_get_htab_fd(struct kvm *kvm, struct kvm_get_htab_fd *ghf) {
int ret;
struct kvm_htab_ctx *ctx;
int rwflag;
if (ghf->flags & ~(KVM_GET_HTAB_BOLTED_ONLY | KVM_GET_HTAB_WRITE))
return -EINVAL;
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
if (!ctx)
return -ENOMEM;
kvm_get_kvm(kvm);
ctx... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_hv.c |
void kvmppc_mmu_debugfs_init(struct kvm *kvm) {
debugfs_create_file("htab", 0400, kvm->debugfs_dentry, kvm,
&debugfs_htab_fops);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c |
static void kvmppc_pmd_free(pmd_t *pmdp) {
kmem_cache_free(kvm_pmd_cache, pmdp);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | void kvmppc_unmap_pte(struct kvm *kvm, pte_t *pte, unsigned long gpa,
unsigned int shift, const struct kvm_memory_slot *memslot,
unsigned int lpid)
{
unsigned long old;
unsigned long gfn = gpa >> PAGE_SHIFT;
unsigned long page_size = PAGE_SIZE;
unsigned long hpa;
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | static void kvmppc_unmap_free_pte(struct kvm *kvm, pte_t *pte, bool full,
unsigned int lpid) {
if (full) {
memset(pte, 0, sizeof(long) << RADIX_PTE_INDEX_SIZE);
} else {
pte_t *p = pte;
unsigned long it;
for (it = 0; it < PTRS_PER_PTE; ++it, ++p) {
if (pte_va... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | static void kvmppc_unmap_free_pud_entry_table(struct kvm *kvm, pud_t *pud,
unsigned long gpa,
unsigned int lpid) {
pmd_t *pmd = pmd_offset(pud, 0);
pud_clear(pud);
kvmppc_radix_flush_pwc(kvm, lpid);
kvmppc_unmap_free_p... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | bool kvmppc_hv_handle_set_rc(struct kvm *kvm, bool nested, bool writing,
unsigned long gpa, unsigned int lpid) {
unsigned long pgflags;
unsigned int shift;
pte_t *ptep;
pgflags = _PAGE_ACCESSED;
if (writing)
pgflags |= _PAGE_DIRTY;
if (nested)
ptep = find_kvm_nested_gu... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | /* Called with kvm->mmu_lock held */
bool kvm_age_radix(struct kvm *kvm, struct kvm_memory_slot *memslot,
unsigned long gfn) {
pte_t *ptep;
unsigned long gpa = gfn << PAGE_SHIFT;
unsigned int shift;
bool ref = false;
unsigned long old, *rmapp;
if (kvm->arch.secure_guest & KVMPPC_SECURE_I... | [
1,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c |
static void add_rmmu_ap_encoding(struct kvm_ppc_rmmu_info *info, int psize,
int *indexp) {
if (!mmu_psize_defs[psize].shift)
return;
info->ap_encodings[*indexp] =
mmu_psize_defs[psize].shift | (mmu_psize_defs[psize].ap << 29);
++(*indexp);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c | int kvmhv_get_rmmu_info(struct kvm *kvm, struct kvm_ppc_rmmu_info *info) {
int i;
if (!radix_enabled())
return -EINVAL;
memset(info, 0, sizeof(*info));
info->geometries[0].page_shift = 12;
info->geometries[0].level_bits[0] = 9;
for (i = 1; i < 4; ++i)
info->geometries[0].level_bits[i] = p9_support... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c |
static int debugfs_radix_open(struct inode *inode, struct file *file) {
struct kvm *kvm = inode->i_private;
struct debugfs_radix_state *p;
p = kzalloc(sizeof(*p), GFP_KERNEL);
if (!p)
return -ENOMEM;
kvm_get_kvm(kvm);
p->kvm = kvm;
mutex_init(&p->mutex);
file->private_data = p;
return nonseeka... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_mmu_radix.c |
void kvmhv_radix_debugfs_init(struct kvm *kvm) {
debugfs_create_file("radix", 0400, kvm->debugfs_dentry, kvm,
&debugfs_radix_fops);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_vio.c |
static void kvm_spapr_tce_liobn_put(struct kref *kref) {
struct kvmppc_spapr_tce_iommu_table *stit =
container_of(kref, struct kvmppc_spapr_tce_iommu_table, kref);
list_del_rcu(&stit->next);
call_rcu(&stit->rcu, kvm_spapr_tce_iommu_table_free);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_vio.c |
static struct page *kvm_spapr_get_tce_page(struct kvmppc_spapr_tce_table *stt,
unsigned long sttpage) {
struct page *page = stt->pages[sttpage];
if (page)
return page;
mutex_lock(&stt->alloc_lock);
page = stt->pages[sttpage];
if (!page) {
page = alloc_page... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_vio.c |
static vm_fault_t kvm_spapr_tce_fault(struct vm_fault *vmf) {
struct kvmppc_spapr_tce_table *stt = vmf->vma->vm_file->private_data;
struct page *page;
if (vmf->pgoff >= kvmppc_tce_pages(stt->size))
return VM_FAULT_SIGBUS;
page = kvm_spapr_get_tce_page(stt, vmf->pgoff);
if (!page)
return VM_FAULT_OO... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_vio.c |
static int kvm_spapr_tce_release(struct inode *inode, struct file *filp) {
struct kvmppc_spapr_tce_table *stt = filp->private_data;
struct kvmppc_spapr_tce_iommu_table *stit, *tmp;
struct kvm *kvm = stt->kvm;
mutex_lock(&kvm->lock);
list_del_rcu(&stt->list);
mutex_unlock(&kvm->lock);
list_for_each_entr... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_64_vio.c |
static long kvmppc_tce_iommu_do_unmap(struct kvm *kvm, struct iommu_table *tbl,
unsigned long entry) {
enum dma_data_direction dir = DMA_NONE;
unsigned long hpa = 0;
long ret;
if (WARN_ON_ONCE(iommu_tce_xchg_no_kill(kvm->mm, tbl, entry, &hpa, &dir)))
return H_TOO_HARD... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_emulate.c | static inline void kvmppc_copyto_vcpu_tm(struct kvm_vcpu *vcpu) {
memcpy(&vcpu->arch.gpr_tm[0], &vcpu->arch.regs.gpr[0],
sizeof(vcpu->arch.gpr_tm));
memcpy(&vcpu->arch.fp_tm, &vcpu->arch.fp, sizeof(struct thread_fp_state));
memcpy(&vcpu->arch.vr_tm, &vcpu->arch.vr, sizeof(struct thread_vr_state));
vcpu... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_emulate.c |
static inline void kvmppc_copyfrom_vcpu_tm(struct kvm_vcpu *vcpu) {
memcpy(&vcpu->arch.regs.gpr[0], &vcpu->arch.gpr_tm[0],
sizeof(vcpu->arch.regs.gpr));
memcpy(&vcpu->arch.fp, &vcpu->arch.fp_tm, sizeof(struct thread_fp_state));
memcpy(&vcpu->arch.vr, &vcpu->arch.vr_tm, sizeof(struct thread_vr_state));
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_emulate.c | static void kvmppc_emulate_treclaim(struct kvm_vcpu *vcpu, int ra_val) {
unsigned long guest_msr = kvmppc_get_msr(vcpu);
int fc_val = ra_val ? ra_val : 1;
uint64_t texasr;
vcpu->arch.regs.ccr =
(vcpu->arch.regs.ccr & ~(CR0_MASK << CR0_SHIFT)) |
(((guest_msr & MSR_TS_MASK) >> (MSR_TS_S_LG - 1)) << C... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_emulate.c |
u32 kvmppc_alignment_dsisr(struct kvm_vcpu *vcpu, unsigned int inst) {
return make_dsisr(inst);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static bool kvmppc_ipi_thread(int cpu) {
unsigned long msg = PPC_DBELL_TYPE(PPC_DBELL_SERVER);
if (kvmhv_on_pseries())
return false;
/* On POWER9 we can use msgsnd to IPI any cpu */
if (cpu_has_feature(CPU_FTR_ARCH_300)) {
msg |= get_hard_smp_processor_id(cpu);
smp_mb();
__asm__ __volatile__(P... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static void kvmppc_fast_vcpu_kick_hv(struct kvm_vcpu *vcpu) {
int cpu;
struct rcuwait *waitp;
waitp = kvm_arch_vcpu_get_wait(vcpu);
if (rcuwait_wake_up(waitp))
++vcpu->stat.generic.halt_wakeup;
cpu = READ_ONCE(vcpu->arch.thread_cpu);
if (cpu >= 0 && kvmppc_ipi_thread(cpu))
return;
/* CPU points... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static void kvmppc_core_vcpu_put_hv(struct kvm_vcpu *vcpu) {
struct kvmppc_vcore *vc = vcpu->arch.vcore;
unsigned long flags;
u64 now;
if (cpu_has_feature(CPU_FTR_ARCH_300)) {
WARN_ON_ONCE(vcpu->arch.state == KVMPPC_VCPU_RUNNABLE);
/*
* Account stolen time when preempted while the vcpu task is
... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void init_vpa(struct kvm_vcpu *vcpu, struct lppaca *vpa) {
vpa->__old_status |= LPPACA_OLD_SHARED_PROC;
vpa->yield_count = cpu_to_be32(1);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int set_vpa(struct kvm_vcpu *vcpu, struct kvmppc_vpa *v,
unsigned long addr, unsigned long len) {
if (addr & (L1_CACHE_BYTES - 1))
return -EINVAL;
spin_lock(&vcpu->arch.vpa_update_lock);
if (v->next_gpa != addr || v->len != len) {
v->next_gpa = addr;
v->len = addr ? len : 0;... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_copy_guest(struct kvm *kvm, gpa_t to, gpa_t from,
unsigned long len) {
struct kvm_memory_slot *to_memslot = NULL;
struct kvm_memory_slot *from_memslot = NULL;
unsigned long to_addr, from_addr;
int r;
from_memslot = gfn_to_memslot(kvm, from >> PAGE_SHIFT);
if (... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_pmu_unavailable(struct kvm_vcpu *vcpu) {
if (!(vcpu->arch.hfscr_permitted & HFSCR_PM))
return EMULATE_FAIL;
vcpu->arch.hfscr |= HFSCR_PM;
return RESUME_GUEST;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int kvmppc_tm_unavailable(struct kvm_vcpu *vcpu) {
if (!(vcpu->arch.hfscr_permitted & HFSCR_TM))
return EMULATE_FAIL;
vcpu->arch.hfscr |= HFSCR_TM;
return RESUME_GUEST;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int kvm_arch_vcpu_ioctl_get_sregs_hv(struct kvm_vcpu *vcpu,
struct kvm_sregs *sregs) {
int i;
memset(sregs, 0, sizeof(struct kvm_sregs));
sregs->pvr = vcpu->arch.pvr;
for (i = 0; i < vcpu->arch.slb_max; i++) {
sregs->u.s.ppc64.slb[i].slbe = vcpu->arch.slb... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static void kvmppc_set_lpcr(struct kvm_vcpu *vcpu, u64 new_lpcr,
bool preserve_top32) {
struct kvm *kvm = vcpu->kvm;
struct kvmppc_vcore *vc = vcpu->arch.vcore;
u64 mask;
spin_lock(&vc->lock);
mask = LPCR_DPFD | LPCR_ILE | LPCR_TC | LPCR_AIL | LPCR_LD;
/* Broken 32-bit version... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static struct kvmppc_vcore *kvmppc_vcore_create(struct kvm *kvm, int id) {
struct kvmppc_vcore *vcore;
vcore = kzalloc(sizeof(struct kvmppc_vcore), GFP_KERNEL);
if (vcore == NULL)
return NULL;
spin_lock_init(&vcore->lock);
spin_lock_init(&vcore->stoltb_lock);
rcuwait_init(&vcore->wait);
vcore->pre... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int debugfs_timings_open(struct inode *inode, struct file *file) {
struct kvm_vcpu *vcpu = inode->i_private;
struct debugfs_timings_state *p;
p = kzalloc(sizeof(*p), GFP_KERNEL);
if (!p)
return -ENOMEM;
kvm_get_kvm(vcpu->kvm);
p->vcpu = vcpu;
file->private_data = p;
return nonseekable_ope... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static ssize_t debugfs_timings_write(struct file *file, const char __user *buf,
size_t len, loff_t *ppos) {
return -EACCES;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_arch_create_vcpu_debugfs_hv(struct kvm_vcpu *vcpu,
struct dentry *debugfs_dentry) {
if (cpu_has_feature(CPU_FTR_ARCH_300) ==
IS_ENABLED(CONFIG_KVM_BOOK3S_HV_P9_TIMING))
debugfs_create_file("timings", 0444, debugfs_dentry, vcpu,
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmhv_set_smt_mode(struct kvm *kvm, unsigned long smt_mode,
unsigned long flags) {
int err;
int esmt = 0;
if (flags)
return -EINVAL;
if (smt_mode > MAX_SMT_THREADS || !is_power_of_2(smt_mode))
return -EINVAL;
if (!cpu_has_feature(CPU_FTR_ARCH_300)) {
if (... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void kvmppc_release_hwthread(int cpu) {
struct paca_struct *tpaca;
tpaca = paca_ptrs[cpu];
tpaca->kvm_hstate.hwthread_req = 0;
tpaca->kvm_hstate.kvm_vcpu = NULL;
tpaca->kvm_hstate.kvm_vcore = NULL;
tpaca->kvm_hstate.kvm_split_mode = NULL;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void init_core_info(struct core_info *cip, struct kvmppc_vcore *vc) {
memset(cip, 0, sizeof(*cip));
cip->n_subcores = 1;
cip->max_subcore_threads = vc->num_threads;
cip->total_threads = vc->num_threads;
cip->subcore_threads[0] = vc->num_threads;
cip->vc[0] = vc;
} | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static bool subcore_config_ok(int n_subcores, int n_threads) {
if (cpu_has_feature(CPU_FTR_ARCH_300))
return n_subcores <= 4 && n_threads == 1;
/* On POWER8, can only dynamically split if unsplit to begin with */
if (n_subcores > 1 && threads_per_subcore < MAX_SMT_THREADS)
return false;
if (n_subcores... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void init_vcore_to_run(struct kvmppc_vcore *vc) {
vc->entry_exit_map = 0;
vc->in_guest = 0;
vc->napping_threads = 0;
vc->conferring_threads = 0;
vc->tb_offset_applied = 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static bool can_dynamic_split(struct kvmppc_vcore *vc, struct core_info *cip) {
int n_threads = vc->num_threads;
int sub;
if (!cpu_has_feature(CPU_FTR_ARCH_207S))
return false;
if (one_vm_per_core && vc->kvm != cip->vc[0]->kvm)
return false;
if (n_threads < cip->max_subcore_threads)
n_threads =... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void prepare_threads(struct kvmppc_vcore *vc) {
int i;
struct kvm_vcpu *vcpu;
for_each_runnable_thread(i, vcpu, vc) {
if (signal_pending(vcpu->arch.run_task))
vcpu->arch.ret = -EINTR;
else if (vcpu->arch.vpa.update_pending ||
vcpu->arch.slb_shadow.update_pending ||
... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static bool recheck_signals_and_mmu(struct core_info *cip) {
int sub, i;
struct kvm_vcpu *vcpu;
struct kvmppc_vcore *vc;
for (sub = 0; sub < cip->n_subcores; ++sub) {
vc = cip->vc[sub];
if (!vc->kvm->arch.mmu_ready)
return true;
for_each_runnable_thread(
i, vcpu, vc) if (signal_pendi... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static inline int kvmppc_clear_host_core(unsigned int cpu) {
int core;
if (!kvmppc_host_rm_ops_hv || cpu_thread_in_core(cpu))
return 0;
core = cpu >> threads_shift;
kvmppc_host_rm_ops_hv->rm_core[core].rm_state.in_host = 0;
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static inline int kvmppc_set_host_core(unsigned int cpu) {
int core;
if (!kvmppc_host_rm_ops_hv || cpu_thread_in_core(cpu))
return 0;
core = cpu >> threads_shift;
kvmppc_host_rm_ops_hv->rm_core[core].rm_state.in_host = 1;
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static void kvmppc_wait_for_exec(struct kvmppc_vcore *vc, struct kvm_vcpu *vcpu,
int wait_state) {
DEFINE_WAIT(wait);
prepare_to_wait(&vcpu->arch.cpu_run, &wait, wait_state);
if (vcpu->arch.state == KVMPPC_VCPU_RUNNABLE) {
spin_unlock(&vc->lock);
schedule();
spin_lock... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static inline bool xive_interrupt_pending(struct kvm_vcpu *vcpu) {
return false;
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static bool kvmppc_vcpu_check_block(struct kvm_vcpu *vcpu) {
if (!vcpu->arch.ceded || kvmppc_vcpu_woken(vcpu))
return true;
return false;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void kvmppc_core_free_memslot_hv(struct kvm_memory_slot *slot) {
vfree(slot->arch.rmap);
slot->arch.rmap = NULL;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | int kvmppc_switch_mmu_to_hpt(struct kvm *kvm) {
unsigned long lpcr, lpcr_mask;
if (nesting_enabled(kvm))
kvmhv_release_all_nested(kvm);
kvmppc_rmap_reset(kvm);
kvm->arch.process_table = 0;
spin_lock(&kvm->mmu_lock);
kvm->arch.radix = 0;
spin_unlock(&kvm->mmu_lock);
kvmppc_free_radix(kvm);
lpcr ... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
void kvmppc_free_host_rm_ops(void) {
if (kvmppc_host_rm_ops_hv) {
cpuhp_remove_state_nocalls(CPUHP_KVM_PPC_BOOK3S_PREPARE);
kfree(kvmppc_host_rm_ops_hv->rm_core);
kfree(kvmppc_host_rm_ops_hv);
kvmppc_host_rm_ops_hv = NULL;
}
}
#endif | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static void kvmppc_free_vcores(struct kvm *kvm) {
long int i;
for (i = 0; i < KVM_MAX_VCORES; ++i)
kfree(kvm->arch.vcores[i]);
kvm->arch.online_vcores = 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int kvmppc_core_emulate_mtspr_hv(struct kvm_vcpu *vcpu, int sprn,
ulong spr_val) {
return EMULATE_FAIL;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int kvmppc_core_emulate_mfspr_hv(struct kvm_vcpu *vcpu, int sprn,
ulong *spr_val) {
return EMULATE_FAIL;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_core_check_processor_compat_hv(void) {
if (cpu_has_feature(CPU_FTR_HVMODE) && cpu_has_feature(CPU_FTR_ARCH_206))
return 0;
if (cpu_has_feature(CPU_FTR_ARCH_300) && radix_enabled())
return 0;
return -EIO;
}
#ifdef CONFIG_KVM_XICS | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_clr_passthru_irq(struct kvm *kvm, int host_irq,
int guest_gsi) {
struct irq_desc *desc;
struct kvmppc_passthru_irqmap *pimap;
int i, rc = 0;
if (!kvm_irq_bypass)
return 0;
desc = irq_to_desc(host_irq);
if (!desc)
return -EIO;
mutex_lock(&kvm-... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static long kvm_arch_vm_ioctl_hv(struct file *filp, unsigned int ioctl,
unsigned long arg) {
struct kvm *kvm __maybe_unused = filp->private_data;
void __user *argp = (void __user *)arg;
long r;
switch (ioctl) {
case KVM_PPC_ALLOCATE_HTAB: {
u32 htab_order;
if (kvmhv... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmhv_enable_dawr1(struct kvm *kvm) {
if (!cpu_has_feature(CPU_FTR_DAWR1))
return -ENODEV;
if (kvm)
kvm->arch.dawr1_enabled = true;
return 0;
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c |
static int kvmppc_radix_possible(void) {
return cpu_has_feature(CPU_FTR_ARCH_300) && radix_enabled();
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.c | static int kvmppc_book3s_init_hv(void) {
int r;
if (!tlbie_capable) {
pr_err("KVM-HV: Host does not support TLBIE\n");
return -ENODEV;
}
/*
* FIXME!! Do we need to check on all cpus ?
*/
r = kvmppc_core_check_processor_compat_hv();
if (r < 0)
return -ENODEV;
r = kvmhv_nested_init();
... | [
0,
1
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv.h |
static inline bool nesting_enabled(struct kvm *kvm) {
return kvm->arch.nested_enable && kvm_is_radix(kvm);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_builtin.c | void kvmppc_set_msr_hv(struct kvm_vcpu *vcpu, u64 msr) {
msr = (msr | MSR_ME) & ~MSR_HV;
/*
* Check for illegal transactional state bit combination
* and if we find it, force the TS field to a safe state.
*/
if ((msr & MSR_TS_MASK) == MSR_TS_MASK)
msr &= ~MSR_TS_MASK;
vcpu->arch.shregs.msr = msr;... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_builtin.c | static void inject_interrupt(struct kvm_vcpu *vcpu, int vec, u64 srr1_flags) {
unsigned long msr, pc, new_msr, new_pc;
msr = kvmppc_get_msr(vcpu);
pc = kvmppc_get_pc(vcpu);
new_msr = vcpu->arch.intr_msr;
new_pc = vec;
if (MSR_TM_TRANSACTIONAL(msr))
new_msr |= MSR_TS_S;
else
new_msr |= msr & MSR_... | [
1,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_builtin.c |
void kvmppc_inject_interrupt_hv(struct kvm_vcpu *vcpu, int vec,
u64 srr1_flags) {
inject_interrupt(vcpu, vec, srr1_flags);
kvmppc_end_cede(vcpu);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_builtin.c | void kvmppc_check_need_tlb_flush(struct kvm *kvm, int pcpu) {
if (cpumask_test_cpu(pcpu, &kvm->arch.need_tlb_flush)) {
flush_guest_tlb(kvm);
cpumask_clear_cpu(pcpu, &kvm->arch.need_tlb_flush);
}
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | static noinline_for_stack void byteswap_pt_regs(struct pt_regs *regs) {
unsigned long *addr = (unsigned long *)regs;
for (; addr < ((unsigned long *)(regs + 1)); addr++)
*addr = swab64(*addr);
} | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c |
void kvmhv_restore_hv_return_state(struct kvm_vcpu *vcpu,
struct hv_guest_state *hr) {
struct kvmppc_vcore *vc = vcpu->arch.vcore;
vc->dpdes = hr->dpdes;
vcpu->arch.hfscr = hr->hfscr;
vcpu->arch.purr = hr->purr;
vcpu->arch.spurr = hr->spurr;
vcpu->arch.ic = hr->ic;
vc-... | [
0,
0
] |
Linux Kernel | arch/powerpc/kvm/book3s_hv_nested.c | static void kvmhv_nested_mmio_needed(struct kvm_vcpu *vcpu, u64 regs_ptr) {
vcpu->arch.trap = 0;
/*
* Since the L2 gprs have already been written back into L1 memory when
* we complete the mmio, store the L1 memory location of the L2 gpr
* being loaded into by the mmio so that the loaded value can be
... | [
1,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.