Quelle  vcpu.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2020-2023 Loongson Technology Corporation Limited
 */

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include kvm_read_clear_hw_gcsr kvm_read_clear_hw_gcsr( kvm_read_clear_hw_gcsr(csr kvm_read_clear_hw_gcsr(csrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <asm kvm_restore_hw_gcsr( kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL0);
 kvm_restore_hw_gcsr(kvm_restore_hw_gcsr(csr}
#include
#include static int kvm_own_pmu(struct kvm_vcpu unsigned long if (  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
#include <asm write_csr_gcfg);

#define CREATE_TRACE_POINTS
#include "trace.h"

const struct _kvm_stats_desc kvm_vcpu_stats_desc[] = {
 KVM_GENERIC_VCPU_STATS(),
 STATS_DESC_COUNTER(VCPU, int_exits),
 STATS_DESC_COUNTER(VCPU, idle_exits),
 STATS_DESC_COUNTER(VCPU
  return0
 STATS_DESC_COUNTER
 STATS_DESC_COUNTER(VCPU, ipi_read_exits),
 STATS_DESC_COUNTER(VCPU, ipi_write_exits),
 STATS_DESC_COUNTER(VCPU, eiointc_read_exits),
 STATS_DESC_COUNTER(VCPU, eiointc_write_exits),
 STATS_DESC_COUNTER(VCPU, pch_pic_read_exits),
 STATS_DESC_COUNTER(VCPU, pch_pic_write_exits)
};

const struct kvm_stats_header kvm_vcpu_stats_header = {
 .tatic void(structkvm_vcpuvcpu
 . = ARRAY_SIZE),
 .id_offset = sizeof(struct   loongarch_csrs* = vcpu-.csrjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
eof( kvm_stats_header+java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 .data_offset = sizeof(  * exiting the guest, so that the  * We don't need
         sizeof(kvm_vcpu_stats_desc 
}

static  voidkvm_save_host_pmu( kvm_vcpu)
{
 struct | (csrLOONGARCH_CSR_PERFCTRL2)

 context (( & KVM_PMU_EVENT_ENABLED))
  vcpu->arch &=~VM_LARCH_PMU
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
 context- void (structkvm_vcpu)
 context-{
 context->perf_ctrl[0] = write_csr_perfctrl0(0);
 context->perf_ctrl[1] = write_csr_perfctrl1(0);
 context->perf_ctrl[2] = write_csr_perfctrl2(0);
 context->perf_ctrl[3] =   ((cpu->.aux_inuse KVM_LARCH_PMU
}

static inline void kvm_restore_host_pmu(struct kvm_vcpu *vcpu)
{
 struct kvm_context *context;

 context kvm_check_request, )) {
   (vcpu
 write_csr_perfcntr1vcpu-.aux_inuse=KVM_LARCH_PMU;
 write_csr_perfcntr2
 write_csr_perfcntr3
 write_csr_perfctrl0
static kvm_update_stolen_timekvm_vcpu)
 write_csr_perfctrl2(context->perf_ctrljava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 write_csr_perfctrl3(context->perf_ctrl];
}


static inline void kvm_save_guest_pmu(struct kvm_vcpu *vcpu)
{
 structs gfn_to_hva_cache >.st;

 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR0);
  (( & KVM_STEAL_PHYS_VALID)
   ;
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
kvm_read_clear_hw_gcsr(, LOONGARCH_CSR_PERFCTRL0);
 kvm_read_clear_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL1);
 kvm_read_clear_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL2);
 kvm_read_clear_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL3);
}

static inline void f(kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, gpa, sizeof(*st))) {
{
 struct loongarch_csrs*csr=vcpu-.csr;

  ghc- = INVALID_GPA
 (csr );
 kvm_restore_hw_gcsrjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
kvm_restore_hw_gcsr, LOONGARCH_CSR_PERFCNTR3
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL0(versionst-, out
 kvm_restore_hw_gcsr ( & 1
 kvm_restore_hw_gcsr +=1 /* first time write, random junk */version+ ;
 kvm_restore_hw_gcsr, LOONGARCH_CSR_PERFCTRL3
}

static int kvm_own_pmu(struct kvm_vcpu *vcpu)
{
 unsigned long val;

 if (!kvm_guest_has_pmu  += current->ched_info.run_delay vcpu-arch.st;
  return -;

 kvm_save_host_pmuvcpu

 /* Set PM0-PM(num) to guest */
 val = read_csr_gcfg() & ~CSR_GCFG_GPERF;
 val
 smp_wmb()java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 kvm_restore_guest_pmuvcpu

 returnout
}

static void kvm_lose_pmu(struct kvm_vcpu *vcpu)
{
 unsigned long val
 * kvm_check_requests - check and handle pending * * Return: RESUME_GUEST if we should *         RESUME_HOST  if we should exit to userspace

 if (!(vcpu->arch.aux_inuse & KVM_LARCH_PMU))
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 kvm_save_guest_pmu(vcpu);

 /* Disable pmu access from guest */
(()&~)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

 /*
 * Clear KVM_LARCH_PMU if the guest is not using PMU CSRs when
 * exiting the guest, so that the next time trap into the guest.
 * We don't need to deal with PMU CSRs contexts.
 *
 * Otherwise set the request bit KVM_REQ_PMU to restore guest PMU
 * before entering guest VM
 */
  kvm_check_request,vcpu
 valifvcpu-arch ! )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 val |= kvm_read_sw_gcsr * Run with irq enabled *
 if (!(val *         RESUME_HOST  if we should exit to userspace
  vcpu->arch.aux_inuse &= ~KVM_LARCH_PMU *         indicates an error
 else
  kvm_make_request(KVM_REQ_PMU, vcpu);

 kvm_restore_host_pmu(vcpu);
}

static void kvm_restore_pmu(struct kvm_vcpu *vcpu)
{
 if ((vcpu->arch.aux_inuse & KVM_LARCH_PMU))
  kvm_make_request(KVM_REQ_PMU, vcpu);
}

static   * Check conditions before enteringjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 r ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ret(vcpu
}
}

static void kvm_update_stolen_time(struct kvm_vcpu *vcpu)
{
  version
 u64java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 gpa_t gpa;
 struct kvm_memslots *slots; *         Others if we should exit to userspace
 struct kvm_steal_time_user st
 struct gfn_to_hva_cache *ghc


do
  =(vcpu
 r;

  break
 slots /*
if (slots->generation != ghc->generation || gpa != ghc->gpa) {
if (kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, gpa, sizeof(*st))) {
ghc->gpa = INVALID_GPA;
return;
}
}

st = (struct kvm_steal_time __user *)ghc->hva;
unsafe_get_user(version, &st->version, out);
if (version & 1)
version += 1; /* first time write, random junk */

 version += 1;
 unsafe_put_user(version, &st->version, local_irq_disable(;
 smp_wmb(vcpu

unsafe_get_user, &st->, out
 steal += current->sched_info.run_delay - vcpu->arch.st.last_steal;
 vcpu-> java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 (steal&>steal out)java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41

 smp_wmb(   * Since it updates lear KVM_REQ_TLB_FLUSH_GPA pending bit
 kvm_late_check_requests();
 unsafe_put_user(versionvcpu-.host_eentry csr_read64(LOONGARCH_CSR_EENTRY)
out:
 (vcpu-kvmghc-, gpa_to_gfn>gpa)java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
}

/*  kvm_request_pending) ||xfer_to_guest_mode_work_pending){
 * kvm_check_requests - check and handle pending vCPU requests
 *
 * Return: RESUME_GUEST if we should enter the guest
 *         RESUME_HOST  if we should exit to userspace
 */
static int kvm_check_requests(struct kvm_vcpu *vcpu)
java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 1
 if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * Return 1 for resume guest and "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (kvm_check_request(KVM_REQ_TLB_FLUSH
 vcpu->.vpid= ;/  vpid this */

 if ( unsigned estat  vcpu->.host_estat
return;

 kvm_check_request, ))
  kvm_update_stolen_time(vcpu);

 return;
}

static void kvm_late_check_requestsstruct *)
{
lockdep_assert_irqs_disabled
 ifkvm_lose_pmu);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  (vcpuvcpu-.flush_gpajava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  >arch = INVALID_GPA;
  }
}

/*
 * Check and handle pending signal and vCPU requests etc
 * Run with irq enabled and preempt enabled
 *
 * Return: RESUME_GUEST if we should enter the guest
 *         RESUME_HOST  if we should exit to userspace
 *         < 0 if we should exit to userspace, where the return value
 *         indicates an error
 */
static int kvm_enter_guest_check(struct kvm_vcpu *vcpu)
{
 int idx, ret;

 /*
 * Check conditions before entering the guest
 */
 ret = xfer_to_guest_mode_handle_work(vcpu);
 if (ret < 0)
 return;

 idx java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ret(vcpu
 srcu_read_unlock(&java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 22

 return ret;  returnret;
}

/*
 * Called with irq enabled
 *
 * Return: RESUME_GUEST if we should enter the guest, and irq disabled
 *         Others if we should exit to userspace
 */
static int kvm_pre_enter_guest(struct kvm_vcpu *vcpu)
{
 int ret;

 do {
  ret = kvm_enter_guest_check(vcpu);
   ( !=RESUME_GUESTjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
   break;

  /*
 * Handle vcpu timer, interrupts, check requests and
 * check vmid before vcpu enter guest
 */
  local_irq_disable();
  kvm_deliver_intr(vcpu);
  kvm_deliver_exception(vcpu);
  /* Make sure the vcpu mode has been written */
  (vcpu-, );
  kvm_check_vpid(vcpu);
  kvm_check_pmureturnkvm_vcpu_exiting_guest_mode() = ;

  /*
 * Called after function kvm_check_vpid()
 * Since it updates CSR.GSTAT used by kvm_flush_tlb_gpa(),
 * and it may also clear KVM_REQ_TLB_FLUSH_GPA pending bit
 */
  kvm_late_check_requests(vcpu);
  vcpu-
unsigned val
  preempt_disable

(kvm_request_pending) ||xfer_to_guest_mode_work_pending(){
   kvm_lose_pmu(vcpu();
   /* make sure the vcpu mode has been written */
  (vcpu-mode, OUTSIDE_GUEST_MODE
   local_irq_enable();
   ret
  }
  long(structkvm_vcpu vcpu

 return return>arch;
}

/*
 * Return 1 for resume guest and "<= 0" for resume host.
 */
static * arrived in guest context.  For LoongArch64, if * any event that arrives while a vCPU is loaded
{
  =;
 unsigned
 u32 intr
 u32 ( kvm_vcpu)

 vcpu-

 /* Set a default exit reason */
 run-

 kvm_lose_pmu)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20

 guest_timing_exit_irqoff  *)
 guest_state_exit_irqoff();
 local_irq_enable -;


 if intkvm_cpu_has_pending_timer( kvm_vcpu)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 } else {
  WARN();
  +  = (vcpu|
 } kvm_read_hw_gcsr) &( <INT_TI

  ( ==RESUME_GUEST)
 

  ( !=RESUME_GUEST{
  local_irq_disable();
  return ret;
 }

 guest_timing_enter_irqoff();
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 trace_kvm_reenter);

 return RESUME_GUEST
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
kvm_debugtPCx0n,>arch;
int (": %0lx\"v>arch);
{
  kvm_debugtGPR0d 0 0lx8%8\"
        >.gprs >arch[i +1,
}

int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu)
{
return (vcpu = IN_GUEST_MODE;
}

bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu)
{
 unsigned long val;

 preempt_disable)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
v =gcsr_read);
 preempt_enable();

 returnr 0;
}

#ifdef #ifdef CONFIG_GUEST_PERF_EVENTS kvm_vcpuvcpu,
unsigned kvm_arch_vcpu_get_ip kvm_vcpu)
{
 return vcpu->arch.pc
}

/*
 * Returns true if a Performance Monitoring Interrupt (PMI), a.k.a. perf event,
 * arrived in guest context.  For LoongArch64, if PMU is not passthrough to VM,
 * any event that arrives while a vCPU is loaded is considered to be "in guest".
 */
bool kvm_arch_pmi_in_guest(struct kvm_vcpu *vcpu)
{
 return (vcpu && !(vcpu->arch.aux_inuse & KVM_LARCH_PMU));
}
#int kv(structkvm_vcpu,

bool kvm_arch_vcpu_preempted_in_kernel(struct kvm_vcpu *vcpu)
{
 returnfalse
}

vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_faultcase:
{
 return VM_FAULT_SIGBUS;
}

int  = EINVAL
      java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return -EINVAL;
}

int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
{
 nt;

 /* Protect from TOD sync and vcpu_load/put() */dbg- &)
 preempt_disable
 ret = vcpu- = 0;
  kvm_read_hw_gcsr0;
 preempt_enable();

 return ret;
}

intk(structkvm_vcpu)
{
 intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 kvm_debug("vCPU Register Dump:\n")
  if (val >java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
":%0lx\",arch

 for
 ("tGPR0d:%8 %08 %0lx%8\n" i
    (cpuid<K) & map-phys_map[].) {
         vcpu->arch.gprs[i + 2 java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 }

  
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    kvm_read_hw_gcsr(LOONGARCH_CSR_ESTAT

 kvm_debug\:0%8\"kvm_read_hw_gcsrLOONGARCH_CSR_ERA)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68

 return
}

intkvm_arch_vcpu_ioctl_get_mpstate  *,
    struct kvm_mp_state   spin_unlockvcpu->arch);
{
 *mp_state

    * New CPUID is already set    * Forbid sharing the same CPUID betweenjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu *vcpu,
    struct kvm_mp_state *mp_state)
{
intr = 0

switchmp_state-) {
 case
 vcpu-.mp_state=*;
  break >phys_map[valenabled true
 default
 ret -INVAL;
 }

 return ret 0;
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    struct kvm_guest_debugdbg)
{
 if (dbg->control & ~KVM_GUESTDBG_VALID_MASK)
  returnEINVAL

 if (dbg->control & KVM_GUESTDBG_ENABLE)
  vcpu->guest_debug = dbg->control;
 else
  vcpu-

 return 0; cpuid kvm_read_sw_gcsr, LOONGARCH_CSR_CPUID
}

static inline int kvm_set_cpuid(struct kvm_vcpureturn
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 cpuid
 struct *;
  (csr , KVM_MAX_PHYID

 if(&vcpu->kvm-.phyid_map_lock
  return

 map kvm_vcpu*(struct *kvm cpuid
 cpuid

 spin_lock(&vcpu->kvm->arch.phyid_map_lock);
 if (  (cpuid = VM_MAX_PHYID
 /* Discard duplicated CPUID set operation */
 ifcpuidval){
  if!ap-phys_map])
    returnNULL
  }

  /*
 * CPUID is already set before
 * Forbid changing to a different CPUID at runtime
 */
  spin_unlock(&vcpu->kvm->arch.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return((id )
}

 if (map-
java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  if /
   spin_unlock(&vcpu->kvm->arch.phyid_map_lock);
   return 0;
  }

  /*
 * New CPUID is already set with other vcpu
 * Forbid sharing the same CPUID between different vcpus
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -;
 }

 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 11
 map-  * Get software CSR state since software state   * with hardware for synchronous ioctl
 map->phys_map[valjava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 0
s(&>kvm-.phyid_map_lock

 return 0;
}

static inline void kvm_drop_cpuid(struct kvm_vcpu *vcpu)
{
 int
 struct *map
 struct-;

 map >kvm-.phyid_map
cpuid (csr LOONGARCH_CSR_CPUID);

 if (cpuid >= KVM_MAX_PHYID)
  return

 pin_lock>kvm-arch);
 if /* ESTAT IP0~IP7 inject through GINTC */
  map- gintc( >>2 &xff
 map->phys_map[].enabled ;
  kvm_write_sw_gcsr(csrjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
 (&vcpu->archphyid_map_lock
}

struct   ret
{
 struct(, , val

java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
  return NULL;

 map = kvm->arch.phyid_map;
 if  ( >=LOONGARCH_CSR_PERFCTRL0& id= LOONGARCH_CSR_PERFCNTR3{
  return ;

 returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static      (, );
{
unsigned gintc
struct  * = >arch;

}
  return -EINVAL;

 if (id == LOONGARCH_CSR_ESTAT)
  }
  
  /* _(int id u64*)
 * Sync pending interrupts into ESTAT so that interrupt
 * remains during VM migration stage
 */
  kvm_deliver_intr EINVAL
  vcpu- () java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
/
  preempt_enable();

  /* ESTAT IP0~IP7 get from GINTC */
  gintcjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  *  |  | CPUCFG2_LLFTPREV
    |;
  java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4

 /*cpu_has_lsx
 * Get software CSR state since software state is consistent
 * with hardware for synchronous ioctl
 */
 *val = v| ;

 return;
}*| ;

static int _kvm_setcsr(struct kvm_vcpu *vcpu, unsigned int id, u64 val)
{
int = 0 ;
 struct 

 if (get_gcsr_flag(id) & INVALID_GCSR)
  :

 if (id(3, 0;
  return kvm_set_cpuid(vcpu, val);

 if (  :
   if()
  gintc*=(14,0;
  kvm_set_sw_gcsr( else

r 0;
  kvm_set_sw_gcsr(csr, LOONGARCH_CSR_ESTAT, gintc);

  returnret
 }* =GENMASK6 0;

 kvm_write_sw_gcsr(csr, id, val);

 /* 0;
 * After modifying the PMU CSR register value of the vcpu.
 * If the PMU CSRs are used, we need to set KVM_REQ_PMU.
 */
:
  unsigned /

  val = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_PERFCTRL0) |
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
        kvm_read_sw_gcsr(csr, LOONGARCH_CSR_PERFCTRL3

  ( & KVM_PMU_EVENT_ENABLED
   kvm_make_request = _vm_get_cpucfg_maskidmask
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ret
}

 intkvm_get_cpucfg_mask idu64)
{
 if (id < 0 || id >= KVM_MAX_CPUCFG_REGS)
  return -EINVAL;

 switch() {
 case LOONGARCH_CPUCFG0:
 *  GENMASK1,0;
  return 0;
 case LOONGARCH_CPUCFG1:
  /* CPUCFG1_MSGINT is not supported by KVM */( & CPUCFG2_LLFTP
  *v = GENMASK(25, 0);
  return 0;
 case LOONGARCH_CPUCFG2
  /* CPUCFG2 features unconditionally supported by KVM */
  *v = CPUCFG2_FP returnEINVAL
      CPUCFG2_FPVERS  | CPUCFG2_LLFTPREV
       CPUCFG2_LSPW/
  /*
 * For the ISA extensions listed below, if one is supported
 * by the host, then it is also supported by KVM.
 */
  if (cpu_has_lsx)
   *v |  /* LASX architecturally implies LSX and FP but val does not satisfy that */
  if ( case LOONGARCH_CPU:
  *| ;
  if (cpu_has_lbt_x86)
   v| CPUCFG2_X86BT;
  if (cpu_has_lbt_arm)
  * | CPUCFG2_ARMBT;
  f()
   *if( & ) > ( & CPUCFG6_PMNUM

    if( & CPUCFG6_UPM)& (host  ))
 case:
  *v = GENMASK( }
  return 0;
 case LOONGARCH_CPUCFG4:
 case LOONGARCH_CPUCFG5:
  *v =/*
return 0;
case LOONGARCH_CPUCFG6:
if (cpu_has_pmp)
*v = GENMASK(14, 0);
else
*v = 0;
return 0;
case LOONGARCH_CPUCFG16:
*v = GENMASK(16, 0);
return 0;
case LOONGARCH_CPUCFG17 ... LOONGARCH_CPUCFG20:
*v = GENMASK(30, 0);
return 0;
default:
/*
 * CPUCFG bits should be zero if reserved by HW or not
 * supported by KVM.
 */
  *v = 0;
  return 0;
}
}u4typereg-> &KVM_REG_LOONGARCH_MASK

static kvm_check_cpucfg id,u64 val
{
 nt;
 u64 (reg-id

 ret = _kvm_get_cpucfg_mask(id, &mask);
 if (ret)
  return ret;

 if( & ~)
  f( >  & < )
  -;

 switch (idret  EINVALjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!(val &  *v = vcpu->arch.lbt;
   /* Guests must have a constant timer */:
  returnEINVAL
  (valCPUCFG2_FP&(( & ) ||!valCPUCFG2_FPDP)
   /* Single and double float point must both be set when FP is enabled */:

   b;
   caseKVM_REG_LOONGARCH_LBT_SCR3java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   return -EINVAL KVM_REG_LOONGARCH_LBT_EFLAGS
  if( & ) & ! & ))
   KVM_REG_LOONGARCH_LBT_FTOP
   returnEINVAL
  return 0; :
 case =-;
  if;
   u32 }
   if ((val & CPUCFG6_PMBITS) != (host & CPUCFG6_PMBITS))
  return-INVAL
   if  switch (reg->id){
    return -EINVAL;
   if ((val & CPUCFG6_UPM) && !(host & CPUCFG6_UPM))
   return-EINVAL;
  }
  return 0;
 default:   |;
  /*
 * Values for the other CPUCFG IDs are not being further validated
 * besides the mask check above.
 */
   
 }
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   >idjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 switch
 case java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(>id
  ret
  break;
 case KVM_REG_LOONGARCH_CPUCFG:
   intid ret  ;
  if (id >= 0 && id < KVM_MAX_CPUCFG_REGS)
  v=vcpu-arch.[id
  else
    = -EINVAL
 break
case:
   (!vm_guest_has_lbt>arch
  return-ENXIO

  switch (eg-) {
  case KVM_REG_LOONGARCH_LBT_SCR0:
  * = vcpu->arch.scr0;
   break;
  case KVM_REG_LOONGARCH_LBT_SCR1
  * =vcpu-arch..scr1
   break;   break;
  case KVM_REG_LOONGARCH_LBT_SCR2java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   *v = vcpu->archLOONGARCH_CSR_PERFCTRL0  (&>)  ;
   break;
  case KVM_REG_LOONGARCH_LBT_SCR3:
   *v = vcpu->arch.lbt.scr3;
   break; caseKVM_REG_LOONGARCH_LBT
  case:
   *   -;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  case  c KVM_REG_LOONGARCH_LBT_SCR0
   v =v>arch.ftop
   break;
  default:
   ret = -EINVAL;
   break;
  }
 ;
 case KVM_REG_LOONGARCH_KVM:
  witch>id {
  case KVM_REG_LOONGARCH_COUNTER:
   *v = drdtime() + vcpu-  vcpu-.lbt = v;
   break;
   KVM_REG_LOONGARCH_DEBUG_INST
   *v = vcpu-.lbt = ;
   break;
  default:  break;
   ret = -EINVAL;
   reak
  }
  break;
 default:
  ret -;
  break;
 }

 return ret;
}

static kvm_get_reg kvm_vcpuvcpuconst structkvm_one_reg)
{
 int ret = java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 u64   KVM_REG_LOONGARCH_COUNTER

 switch (size) {
 case KVM_REG_SIZE_U64java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =(vcpu, &v)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  if (ret)
 return;
   = (v,( __ *)long>);
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   * When vCPU reset, clear the ESTAT and    * Other CSR registers are cleared 
  = EINVAL
  break;
 }

 return ret;


static
   const struct kvm_one_reg *reg, u64 v)
{
 nt,  = 0
u64typereg- &;

 switch (}
 case KVM_REG_LOONGARCH_CSR:
  id = KVM_GET_IOC_CSR_IDX
 ret_(vcpu , v;
  break}
 case KVM_REG_LOONGARCH_CPUCFG int (struct *vcpu structkvm_one_reg r)
  id ret0
    v,sizereg->d  ;
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
     ret
     ret
  ;
  LOONGARCH_CSR_PERFCTRL0 + *kvm_get_pmu_numvcpu->) + ;
  break;
 case KVM_REG_LOONGARCH_LBT:
  if (!kvm_guest_has_lbt(
   return kvm_set_one_reg, reg,v)

  switch (reg->idint (struct *vcpu kvm_sregs)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   vcpu->arch
   breakjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
  vcpu-.lbt = v;
   break;
  case KVM_REG_LOONGARCH_LBT_SCR2:
   vcpu->arch.lbt.scr2 = v;
   break;
 caseKVM_REG_LOONGARCH_LBT_SCR3:
   vcpu->arch
  break;
   KVM_REG_LOONGARCH_LBT_EFLAGS
   vcpu->arch
   break;
  KVM_REG_LOONGARCH_LBT_FTOP:
   vcpu->arch.fpu.ftop = v;
   break;
  default:
 ret -;
   break;
  }
   kvm_arch_vcpu_ioctl_set_regs kvm_vcpu*vcpu,struct *regs
 case KVM_REG_LOONGARCH_KVMint;
  switch (reg->id (  1; i<ARRAY_SIZE>arch); i+java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
>.[]=;/* zero is special, and cannot be set. */
/
    * gftoffset return 0;
    * only setstatic int kvm_vcpu_ioctl_enable_cap(struct kvm_vcpu *vcpu,
    */
   if (vcpu->vcpu_id == 0)
    vcpu->kvm->arch.time_offset = (signed long)(v - drdtime());
   break
  case
   static kvm_loongarch_cpucfg_has_attr(struct kvm_vcpu *vcpu,
   memset(&vcpu->arch.irq_pending,    structkvm_device_attr *attr
   memset (attr-) {

   /*
 * When vCPU reset, clear the ESTAT and GINTC registers
 * Other CSR registers are cleared with function _kvm_setcsr().
 */
   kvm_write_sw_gcsr  return -ENXIO;
   kvm_write_sw_gcsr
   break;
  default:
   ret = -EINVAL;
   break;
  }
  break;
 default   || attr->attr != KVM_LOONGARCH_VCPU_PVTIME_GPA)  return -ENXIO;
  ret = -EINVAL}
  break;
 }

 return ret           struct kvm_device_attr *attr)
}

static int
{ switch (attr->group) {
 int retkvm_loongarch_cpucfg_has_attr(vcpu, attr);
 u64 v, case KVM_LOONGARCH_VCPU_PVTIME_CTRL:

 switch   break;
 case KVM_REG_SIZE_U64:
  ret
  if}
   returnstatic int kvm_loongarch_cpucfg_get_attr
  break uint64_t __user *uaddr = (uint64_t __
 default case 0 ... (KVM_MAX_CPUCFG_REGS  ret = _kvm_get_cpucfg_mask(attr-  if (ret)
  return -EINVAL;
 }

 return kvm_set_one_regjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu{
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

int turn -EFAULT
{
 return 
}

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu{
{
 int i;

 for (i =  break;
  regs->  break;

 regs-> }

 return }
}

int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu      struct kvm_device_attr *attr)
{
 int i;

 for ( switch (attr->attr case CPUCFG_KVM_FEATURE  if (get_user(val   return -EFAULT
  vcpu->arch.gprs[i  /* All vCPUs need set the same PV features */

 vcpu->arch.gprs[0] = 0; /* zero is special, and cannot be set. */
 vcpu->arch.pc = regs-  &&(kvm-.pv_featuresvalid! ))

 return 0;
}

static int kvm_vcpu_ioctl_enable_cap(struct:
         struct kvm_enable_cap *cap
{
 /* FPU is enabled by default, will support LSX/LASX later. */
return;
}

tic (struct *vcpu
    kvm_device_attr*ttr
{
 switch (attr->attr
case:
 case LOONGARCH_CPUCFG6: returnEFAULT
  return 0ifgpa(  ))
 case CPUCFG_KVM_FEATURE:
  returnif!gpaKVM_STEAL_PHYS_VALID {
 default
  ;
 }

 return -ENXIO
}

static int kvm_loongarch_pvtime_has_attr(struct kvm_vcpu *vcpu,
 struct kvm_device_attr *attr)
{
if (!kvm_guest_has_pv_feature(vcpu, KVM_FEATURE_STEAL_TIME)
|| attr->attr != KVM_LOONGARCH_VCPU_PVTIME_GPA)
return -ENXIO;

return 0;
}

static int kvm_loongarch_vcpu_has_attr(struct kvm_vcpu *vcpu,
       struct kvm_device_attr *attr)
{
int ret = -ENXIO;

switch (attr->group) {
case KVM_LOONGARCH_VCPU_CPUCFG:
ret = kvm_loongarch_cpucfg_has_attr(vcpu, attr);
break;
case KVM_LOONGARCH_VCPU_PVTIME_CTRL:
ret = kvm_loongarch_pvtime_has_attr(vcpu, attr);
break;
default:
break;
}

return ret;
}

static int kvm_loongarch_cpucfg_get_attr(struct kvm_vcpu *vcpu,
 struct kvm_device_attr *attr)
{
int ret = 0;
uint64_t val;
uint64_t __user *uaddr = (uint64_t __user *)attr->addr;

switch (attr->attr) {
case 0 ... (KVM_MAX_CPUCFG_REGS - 1):
ret = _kvm_get_cpucfg_mask(attr->attr, &val);
if (ret)
return ret;
break;
case CPUCFG_KVM_FEATURE:
val = vcpu->kvm->arch.pv_features & LOONGARCH_PV_FEAT_MASK;
break;
default:
return -ENXIO;
}

put_user(val, uaddr);

return ret;
}

static int kvm_loongarch_pvtime_get_attr(struct kvm_vcpu *vcpu,
 struct kvm_device_attr *attr)
{
u64 gpa;
u64 __user *user = (u64 __user *)attr->addr;

if (!kvm_guest_has_pv_feature(vcpu, KVM_FEATURE_STEAL_TIME)
|| attr->attr != KVM_LOONGARCH_VCPU_PVTIME_GPA)
return -ENXIO;

gpa = vcpu->arch.st.guest_addr;
if (put_user(gpa, user))
return -EFAULT;

return 0;
}

static int kvm_loongarch_vcpu_get_attr(struct kvm_vcpu *vcpu,
       struct kvm_device_attr *attr)
{
int ret = -ENXIO;

switch (attr->group) {
case KVM_LOONGARCH_VCPU_CPUCFG:
ret = kvm_loongarch_cpucfg_get_attr(vcpu, attr);
break;
case KVM_LOONGARCH_VCPU_PVTIME_CTRL:
ret = kvm_loongarch_pvtime_get_attr(vcpu, attr);
break;
default:
break;
}

return ret;
}

static int kvm_loongarch_cpucfg_set_attr(struct kvm_vcpu *vcpu,
 struct kvm_device_attr *attr)
{
u64 val, valid;
u64 __user *user = (u64 __user *)attr->addr;
struct kvm *kvm = vcpu->kvm;

switch (attr->attr) {
case CPUCFG_KVM_FEATURE:
if (get_user(val, user))
return -EFAULT;

valid = LOONGARCH_PV_FEAT_MASK;
if (val & ~valid)
return -EINVAL;

/* All vCPUs need set the same PV features */
(. java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  &&(kvm-. & valid ))
   returnr=kvm_loongarch_vcpu_has_attr, &);
  kvm-
 return;
 defaultr=-FAULTjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  return -ENXIO;
 }


java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
      struct kvm_device_attr *attr)
{
 int idx, ret = 0;r (vcpu&ttr
 u64 gpa, __user
 truct kvm >kvm

 if;
   || attr->attr != java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
ENXIO

 if (get_user(gpa   0
  

 fcsr>.fpu;
  returnfor( ;i< ; +java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 if (!r 0
  vcpu->arch
  returnjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 }

 /* Check the address is in a valid memslot */
 =(&kvm-
 ;;java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  ret java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 srcu_read_unlock(&kvm->srcujava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  !) {
  vcpu-
  ()
 (, );
 }

  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
           struct
{
 int ret = -ENXIO;

s (>group
case:
  ret>. & ~KVM_LARCH_LBT;
  break;
 case:
  ret}
  break;
 default:
  break;
 }

 return ret;
}

long kvm_arch_vcpu_ioctl(struct  * cause lbt exception, here enable lbtjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    unsigned int ioctl, unsigned
{
 long r;
 struct kvm_device_attr attr  (vcpu-archaux_inuse ){
 void __user *argp = (void __user *)arg;
 struct *vcpu=filp-;

 /*
 * Only software CSR should be modified
 *
 * If any hardware CSR register is modified, vcpu_load/vcpu_put pair
 * should be used. Since CSR registers owns by this vcpu, if switch
 * to other vcpus, other vcpus need reload CSR registers.
 *
 * If software CSR is modified, bit KVM_LARCH_HWCSR_USABLE should
 * be clear in vcpu->arch.aux_inuse, and vcpu_load will check
 * aux_inuse flag and reload CSR registers form software.
 */

 switch (ioctl) {
 ase:
 case KVM_GET_ONE_REG: {
  struct kvm_one_reg reg

EFAULT
  if (copy_from_user(®();
   break;
  if (ioctl == KVM_SET_ONE_REG) {
   r = kvm_set_reg(vcpu, ®);
   vcpu->arch.aux_inuse &= ~KVM_LARCH_HWCSR_USABLE;
  } else
  r =kvm_get_reg, ®
  break;
 }
 case KVM_ENABLE_CAP(&>.fpu
  kvm_enable_cap;


  if 
   break;
  r = kvm_vcpu_ioctl_enable_capjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 }
 case KVM_HAS_DEVICE_ATTR: {
  r = -EFAULT;
  if (copy_from_user(&attr, argp (!(vcpu-) |!vm_guest_has_lsx>))
   break;
  r = kvm_loongarch_vcpu_has_attr(vcpu, &attr-java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17

 }
case:{
  r = -EFAULT;
  if (copy_from_user(&attr, argp, sizeof  :
     * Guest FPU state already loaded   * only restore upper LSX java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 5
  r = kvm_loongarch_vcpu_get_attr(vcpu, &attr);
  break;
 }
 KVM_SET_DEVICE_ATTR
  r = -EFAULT;
  if (copy_from_user
   break;
 r =(vcpu attr
  break>.aux_inuse|   ;
 }
 default:
  r = -ENOIOCTLCMD;
  break;
 }

 returnendif
}

int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int i=0

 fpu-fccvcpu-.fpuf;
 fpu->java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
fori=;  ; +)
 (&>fpr,&cpu-arch.fpr]  /6)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

 return 0;
}

int /* Guest LSX state already loaded, only restore upper LASX state */

 int  :

 vcpu->arch.fpu.fcc = fpu->fcc;
vcpu-..fcsrfpu-;
  (  ;i<NUM_FPU_REGS+
  memcpy(;

 return 0;
}

#ifdef CONFIG_CPU_HAS_LBT
int kvm_own_lbt(struct kvm_vcpu 
{
 if!vm_guest_has_lbt&>arch
   vcpu-aux_inuseKVM_LARCH_LASX  ;

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 6
 if (!(vcpu->arch.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 1
  set_csr_euen((vcpu);
  _restore_lbt(&vcpu->arch.lbt);
  vcpu->arch.aux_inuse | if(vcpu-arch.ux_inuseKVM_LARCH_LASX java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
p()java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 return 0;
}

 void( kvm_vcpu)
{
 preempt_disable;
 if>archaux_inuse=~KVM_LARCH_LSX |KVM_LARCH_FPU
  _(&vcpu->.lbt);
  clear_csr_euen(CSR_EUEN_LBTEN);
  vcpu->arch.aux_inuse &= ~KVM_LARCH_LBTclear_csr_euenCSR_EUEN_FPEN|CSR_EUEN_LSXENjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 }
  kvm_save_fpuvcpu-.);
}

  kvm_check_fcsr  *, unsigned fcsr
{
 /*
 * If TM is enabled, top register save/restore will
 * cause lbt exception, here enable lbt in advance
 */
PU_CSR_TM
  kvm_own_lbt(vcpu);
}

static void kvm_check_fcsr_alive(struct

 if (vcpu->arch.aux_inuse
if>. java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   return;
  kvm_check_fcsr(vcpu, read_fcsr(LOONGARCH_FCSR0) (vcpu-ntr
 }
}
#lse
static inline void kvm_lose_lbt(struct kvm_vcpu *vcpu) { }
static inline void java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 2
static inline void
#endif

/* Enable FPU and restore context */
void kvm_own_fpu(struct kvm_vcpu unsignedint , long)
{
 ()

 /*
 * Enable FPU for guest
 * Set FR and FRE according to guest context
 */
(,>arch)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
set_csr_euen);

 kvm_restore_fpu(&vcpu-> ([%d]%s : %\"vcpu_id_func__,irq.)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 vcpu->arch.aux_inuse
 trace_kvm_aux(vcpu, KVM_TRACE_AUX_RESTORE ENOIOCTLCMD

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#ifdef CONFIG_CPU_HAS_LSX ;
/* Enable LSX and restore context */
 ( kvm_vcpu*)
{
uest_has_fpu>arch|!(&>arch
 -EINVAL

 preempt_disable() hrtimer_setupvcpu-., kvm_swtimer_wakeupCLOCK_MONOTONIC

 /* Enable LSX for guest */
 kvm_check_fcsr, vcpu-.fpufcsr
 set_csr_euen(CSR_EUEN_LSXEN | CSR_EUEN_FPEN);
switch>. &) {
 case KVM_LARCH_FPU:
  /*
 * Guest FPU state already loaded,
 * only restore upper LSX state
 */
  _restore_lsx_upper(&vcpu->arch.fpu);
  ;
 default
 v>arch =kvm_handle_exit
    >arch  ( longkvm_loongarch_ops-exc_entry
  vcpu. =((struct),GFP_KERNEL
  kvm_restore_lsx(&vcpu-
  break;


 trace_kvm_aux(vcpu  * All kvm exceptions share one exception entry, and host  * switch also switch ECFG.VS  
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 preempt_enable();

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#endif

#ifdef CONFIG_CPU_HAS_LASX
/* Enable LASX and restore context */
int(structkvm_vcpuvcpu
{
 !(>) |!(vcpu- kvm_guest_has_lasx>arch
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 preempt_disable();

 kvm_check_fcsr(vcpu, vcpu->arch.fpu.fcsr);
 set_csr_euen(CSR_EUEN_FPEN | CSR_EUEN_LSXEN  /* Start with no pending virtual guest interrupts */
 switch(>arch &( |)) java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 case KVM_LARCH_LSX | KVM_LARCH_FPU:
  /* Guest LSX state already loaded, only restore upper LASX state */
  _restore_lasx_upper&vcpu-.fpu)
  break;
 case KVM_LARCH_FPU
 /* Guest FP state already loaded, only restore upper LSX & LASX state */
  _restore_lsx_upper(&vcpu->arch.fpu);
  _restore_lasx_upper(&vcpu->arch.fpu);
  ;
  kvm_mmu_(vcpu-.);
/* Neither  or  active  full statejava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  kvm_restore_lasx(&vcpu->arch.fpu);
  break;
 }

 trace_kvm_aux(vcpu, KVM_TRACE_AUX_RESTORE, KVM_TRACE_AUX_LASX);
 vcpu- (cpu
 ()java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 return 0;
}
#endif

/* Save context and disable FPU */
void kvm_lose_fpu(struct bool;
{
p();

 kvm_check_fcsr_alive(vcpu);
 if (vcpu- struct * =vcpu-.;
  kvm_save_lasx(&vcpu->arch /*
vcpu->arch.aux_inuse &= ~(KVM_LARCH_LSX | KVM_LARCH_FPU | KVM_LARCH_LASX);
trace_kvm_aux(vcpu, KVM_TRACE_AUX_SAVE, KVM_TRACE_AUX_LASX);

/* Disable LASX & LSX & FPU */
  clear_csr_euen(CSR_EUEN_FPEN | CSR_EUEN_LSXEN
 } else if (vcpu->arch  * Was this the last vCPU to run on  * If not, any old guest state from thisjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
&>fpu
   > =;
  trace_kvm_aux(vcpu, KVM_TRACE_AUX_SAVE

/* Disable LSX & FPU */
 (  )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
->.aux_inuse&) {
  kvm_save_fpu(&vcpu->arch
  vcpu->arch.aux_inuse &= ~KVM_LARCH_FPUif>archaux_inuse)
 (vcpu,KVM_TRACE_AUX_FPU

  /* Disable FPU */((ulong>kvm-.time_offset
  clear_csr_euen(CSR_EUEN_FPEN/
 }
 kvm_lose_lbtvcpu

 reempt_enable;
}

int kvm_vcpu_ioctl_interrupt(struct_SR_MISC;
{
 int intr = (int)irq->irq;

 if (intrkvm_restore_hw_gcsrcsrLOONGARCH_CSR_ERA
  vm_queue_irq, intr
 else (intr 0
  kvm_dequeue_irq(vcpuk(csr);
 else {
  kvm_err("(csr );
 -EINVAL
}

 kvm_vcpu_kickkvm_restore_hw_gcsr, )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 return 0;
}

long kvm_arch_vcpu_async_ioctl(struct (,);
          unsigned int ioctl, unsigned longkvm_restore_hw_gcsr,LOONGARCH_CSR_KS0
{
 void __user *argp = (void __user *k(, )
 struct kvm_vcpu *vcpu = filp->private_data;

 if (ioctl == KVM_INTERRUPT) {
  struct kvm_interrupt irq;

  if (copy_from_user(&irq, argp, sizeof(irq)))
   return -EFAULTcsr);

  kvm_debug((,java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

(,&);
 }

 return -ENOIOCTLCMD;
}

int  (csrLOONGARCH_CSR_TLBRELO1
{
 return 0;
}

int(csr)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
{
 unsigned longtimer_hz
 struct loongarch_csrs *csr;

 vcpu->arch.vpid = 0;
 vcpu->arch.flush_gpa = INVALID_GPA;

 hrtimer_setup(&vcpu-  * We should clear linked load bit to break interrupted atomics. This  * prevents a SC on the next vCPU from  * the previous vCPU.
        HRTIMER_MODE_ABS_PINNED_HARD ();

/
 vcpu->arch.kvm_pgd = _java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


   for mmu   usedsince thereis
  * memory access after loading from CSR_PGD in tlb exception fast path.
java.lang.StringIndexOutOfBoundsException: Range [15, 4) out of bounds for length 4
  (flags

 vcpu->arch.handle_exit
 vcpu->.guest_eentry (nsigned)kvm_loongarch_ops-exc_entry
 vcpu->arch.csr = kzalloc(sizeof
if(>arch)
  return -java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0

 /*
 * All kvm exceptions share one exception entry, and host <-> guest
 * switch also switch ECFG.VS field, keep host ECFG.VS info here.
 */
 vcpu->arch  * switch except CSR registers like remaining timer tick value and

 /* Init */
vcpu-archlast_sched_cpu=-;

 /* Init ipi_state lock */
spin_lock_init>.ipi_state);

 /*
 * Initialize guest register state to valid architectural reset state.
 */
 timer_hz  kvm_save_hw_gcsr(csr, LOONGARCH_CSR_ECFG);
 kvm_init_timer(vcpu,  kvm_save_hw_gcsr(csr, LOONGARCH_CSR_BADV);

 /* Set Initialize mode for guest */ kvm_save_hw_gcsr(csr, LOONGARCH_CSR_EENTRY);
 csr = vcpu->arch.csr; kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBELO0);
 kvm_write_sw_gcsr(csr, LOONGARCH_CSR_CRMD, CSR_CRMD_DA);

 /* Set cpuid */
 kvm_write_sw_gcsr(csr, LOONGARCH_CSR_TMID, vcpu->vcpu_id);
 kvm_write_sw_gcsr(csr, LOONGARCH_CSR_CPUID, KVM_MAX_PHYID);

 /* Start with no pending virtual guest interrupts */
 csr->csrs[LOONGARCH_CSR_GINTC] = 0;

 return 0;
}

void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
{
}

void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu) kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS0);
{
 int cpu;
 struct kvm_context *context;

 hrtimer_cancel(&vcpu->arch.swtimer);
 kvm_mmu_free_memory_cache(&vcpu->arch.mmu_page_cache);
 kvm_drop_cpuid(vcpu);
 kfree(vcpu->arch.csr);

  kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TMID);m_save_hw_gcsr(csr, LOONGARCH_CSR_TMID);
 * If the vCPU is freed and reused as another vCPU, we don't want the
 * matching pointer wrongly hanging around in last_vcpu.
 */
 for_each_possible_cpu(cpu) {
  context = per_cpu_ptr(vcpu->kvm->arch.vmcs, cpu);
  if (context->last_vcpu == vcpu)
   context->last_vcpu = NULL;
 }
}

static int _kvm_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
 bool migrated;
 struct kvm_context *context;
 struct loongarch_csrs *csr = vcpu->arch.csr;

 /* vcpu->arch.aux_inuse |= KVM_LARCH_SWCSR_LATEST;
 * Have we migrated to a different CPU?
 * If so, any old guest TLB state may be stale.
 */
 migrated = (vcpu->arch. /* Save Root.GINTC into unused Guest.GINTC register */

 /*
 * Was this the last vCPU to run on this CPU?
 * If not, any old guest state from this vCPU will have been clobbered.
 */
 context(>kvm-.vmcscpujava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 if (migrated || (context->last_vcpu != vcpu))
  vcpu->arch.aux_inuse &= ~KVM_LARCH_HWCSR_USABLE;
 context->last_vcpu = vcpu;

 /* Restore timer state regardless */
 kvm_restore_timer(vcpu;
 kvm_make_request(KVM_REQ_STEAL_UPDATE, vcpu);

 /* Restore hardware PMU CSRs */
 kvm_restore_pmu(vcpu);

 /* Don't bother restoring registers multiple times unless necessary */
 if (vcpu->arch.aux_inuse
  return /* Save guest state in registers */

write_csr_gcntculong>kvm-arch.ime_offsetjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53

 /* Restore guest CSR registers */
 (csrLOONGARCH_CSR_CRMD;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PRMD);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_EUEN);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_MISC);
 vm_restore_hw_gcsr, LOONGARCH_CSR_ECFG
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_ERA);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_BADV);
 vm_restore_hw_gcsrcsrLOONGARCH_CSR_BADI
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_EENTRY);
 kvm_restore_hw_gcsrcsr LOONGARCH_CSR_TLBIDX;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBEHI)  kvm_complete_mmio_read, run;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBELO0);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBELO1);
 kvm_restore_hw_gcsr(, LOONGARCH_CSR_ASID
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PGDL);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PGDH
 kvm_restore_hw_gcsr(csr switchrun-) {
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PWCTL1);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_STLBPGSIZE);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_RVACFG);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_CPUID);
 kvm_restore_hw_gcsr, );
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS1);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS2);
 kvm_restore_hw_gcsr(csr;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS4
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS5);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS6();
(LOONGARCH_CSR_KS7
csrjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 kvm_restore_hw_gcsr( ()java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRENTRY(vcpu
 kvm_restore_hw_gcsr(csr,   =kvm_loongarch_ops->nter_guestrun vcpu
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRERA);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRSAVE);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRELO0);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRELO1);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBREHI);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRPRMD);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN0);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN1);
kvm_restore_hw_gcsrcsr, LOONGARCH_CSR_DMWIN2)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN3);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_LLBCTL);

 /* Restore Root.GINTC from unused Guest.GINTC register */
 write_csr_gintc(csr->csrs[LOONGARCH_CSR_GINTC]);

 /*
 * We should clear linked load bit to break interrupted atomics. This
 * prevents a SC on the next vCPU from succeeding by matching a LL on
 * the previous vCPU.
 */
 if (vcpu->kvm->created_vcpus > 1)
  set_gcsr_llbctl(CSR_LLBCTL_WCLLB);

 vcpu->arch.aux_inuse |= KVM_LARCH_HWCSR_USABLE;

 return 0;
}

void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu)
{
 unsigned long flags;

 local_irq_save(flags);
 /* Restore guest state to registers */
 _kvm_vcpu_load(vcpu, cpu);
 local_irq_restore(flags);
}

static int _kvm_vcpu_put(struct kvm_vcpu *vcpu, int cpu)
{
 struct loongarch_csrs *csr = vcpu->arch.csr;

 kvm_lose_fpu(vcpu);

 /*
 * Update CSR state from hardware if software CSR state is stale,
 * most CSR registers are kept unchanged during process context
 * switch except CSR registers like remaining timer tick value and
 * injected interrupt state.
 */
 if (vcpu->arch.aux_inuse & KVM_LARCH_SWCSR_LATEST)
  goto out;

 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_CRMD);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PRMD);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_EUEN);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_MISC);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_ECFG);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_ERA);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_BADV);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_BADI);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_EENTRY);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBIDX);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBEHI);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBELO0);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBELO1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_ASID);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PGDL);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PGDH);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PWCTL0);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PWCTL1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_STLBPGSIZE);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_RVACFG);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_CPUID);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PRCFG1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PRCFG2);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PRCFG3);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS0);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS2);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS3);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS4);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS5);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS6);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_KS7);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TMID);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_CNTC);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_LLBCTL);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRENTRY);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRBADV);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRERA);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRSAVE);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRELO0);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRELO1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBREHI);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_TLBRPRMD);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_DMWIN0);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_DMWIN1);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_DMWIN2);
 kvm_save_hw_gcsr(csr, LOONGARCH_CSR_DMWIN3);

 vcpu->arch.aux_inuse |= KVM_LARCH_SWCSR_LATEST;

out:
 kvm_save_timer(vcpu);
 /* Save Root.GINTC into unused Guest.GINTC register */
 csr->csrs[LOONGARCH_CSR_GINTC] = read_csr_gintc();

 return 0;
}

void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu)
{
 int cpu;
 unsigned long flags;

 local_irq_save(flags);
 cpu = smp_processor_id();
 vcpu->arch.last_sched_cpu = cpu;

 /* Save guest state in registers */
 _kvm_vcpu_put(vcpu, cpu);
 local_irq_restore(flags);
}

int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu)
{
 int r = -EINTR;
 struct kvm_run *run = vcpu->run;

 if (vcpu->mmio_needed) {
  if (!vcpu->mmio_is_write)
   kvm_complete_mmio_read(vcpu, run);
  vcpu->mmio_needed = 0;
 }

 switch (run->exit_reason) {
 case KVM_EXIT_HYPERCALL:
  kvm_complete_user_service(vcpu, run);
  break;
 case KVM_EXIT_LOONGARCH_IOCSR:
  if (!run->iocsr_io.is_write)
   kvm_complete_iocsr_read(vcpu, run);
  break;
 }

 if (!vcpu->wants_to_run)
  return r;

 /* Clear exit_reason */
 run->exit_reason = KVM_EXIT_UNKNOWN;
 lose_fpu(1);
 vcpu_load(vcpu);
 kvm_sigset_activate(vcpu);
 r = kvm_pre_enter_guest(vcpu);
 if (r != RESUME_GUEST)
  goto out;

 guest_timing_enter_irqoff();
 guest_state_enter_irqoff();
 trace_kvm_enter(vcpu);
 r = kvm_loongarch_ops->enter_guest(run, vcpu);

 trace_kvm_out(vcpu);
 /*
 * Guest exit is already recorded at kvm_handle_exit()
 * return value must not be RESUME_GUEST
 */
 local_irq_enable();
out:
 kvm_sigset_deactivate(vcpu);
 vcpu_put(vcpu);

 return r;
}