Quelle  vcpu.c   Sprache: C

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

#include <linux/*
#include <linux/entry-kvm.h>
#include <asm/fpu.h>
#include <asm/lbt.h>
#include <asm/loongarch.h>
#include <asm/setup.h>
#include <asm/time.h>

#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, cpucfg_exits),
STATS_DESC_COUNTER(VCPU, signal_exits),
STATS_DESC_COUNTER(VCPU, hypercall_exits),
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 = {
.name_size = KVM_STATS_NAME_SIZE,
.num_desc = ARRAY_SIZE(kvm_vcpu_stats_desc),
.id_offset = sizeof(struct kvm_stats_header),
.desc_offset = sizeof(struct kvm_stats_header) + KVM_STATS_NAME_SIZE,
.data_offset = sizeof(struct kvm_stats_header) + KVM_STATS_NAME_SIZE +
       sizeof(kvm_vcpu_stats_desc),
};

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

context = this_cpu_ptr(vcpu->kvm->arch.vmcs);
context->perf_cntr[0] = read_csr_perfcntr0();
context->perf_cntr[1] = read_csr_perfcntr1();
context->perf_cntr[2] = read_csr_perfcntr2();
context->perf_cntr[3] = read_csr_perfcntr3();
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] = write_csr_perfctrl3(0);
}

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

context = this_cpu_ptr(vcpu->kvm->arch.vmcs);
write_csr_perfcntr0(context->perf_cntr[0]);
write_csr_perfcntr1(context->perf_cntr[1]);
write_csr_perfcntr2(context->perf_cntr[2]);
write_csr_perfcntr3(context->perf_cntr[3]);
write_csr_perfctrl0(context->perf_ctrl[0]);
write_csr_perfctrl1(context->perf_ctrl[1]);
write_csr_perfctrl2(context->perf_ctrl[2]);
write_csr_perfctrl3(context->perf_ctrl[3]);
}


static inline void kvm_save_guest_pmu(struct kvm_vcpu *vcpu)
{
struct loongarch_csrs *csr = vcpu->arch.csr;

kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR0);
kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR1);
kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR2);
kvm_save_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR3);
kvm_read_clear_hw_gcsr(csr, 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 kvm_restore_guest_pmu(struct kvm_vcpu *vcpu)
{
struct loongarch_csrs *csr = vcpu->arch.csr;

kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR0);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR1);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR2);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCNTR3);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL0);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL1);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL2);
kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PERFCTRL3);
}

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

if (!kvm_guest_has_pmu(&vcpu->arch))
return -EINVAL;

kvm_save_host_pmu(vcpu);

/* Set PM0-PM(num) to guest */
 val = read_csr_gcfg() & ~CSR_GCFG_GPERF;
 val |= (kvm_get_pmu_num(&vcpu->arch) + 1) << CSR_GCFG_GPERF_SHIFT;
 (val;

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

 0
java.lang.StringIndexOutOfBoundsException: Range [19, 1) out of bounds for length 1

tatic kvm_lose_pmu  *)
{
 unsigned longnum_desc(kvm_vcpu_stats_desc
struct csr>arch;

 if (!(vcpu->arch.aux_inuse & KVM_LARCH_PMU))
  return;

  .desc_offset = siz(truct) +KVM_STATS_NAME_SIZE,

 /* Disable pmu access from guest */
 write_csr_gcfg(read_csr_gcfg() & ~CSR_GCFG_GPERF);

 /*
 * 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
 */
 val = kvm_read_sw_gcsr(csr;
staticinline kvm_save_host_pmustruct *vcpu
 val=kvm_read_sw_gcsr, LOONGARCH_CSR_PERFCTRL2;
 val |= 
 if!valKVM_PMU_EVENT_ENABLED))
.aux_inuse=~;
else
  kvm_make_request(KVM_REQ_PMU, vcpu);

 kvm_restore_host_pmu(vcpu);
}

staticvoid kvm_restore_pmustruct  *vcpu
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
if(cpu-arch &))
  kvm_make_request(KVM_REQ_PMUjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void kvm_check_pmu(struct 
{
 if((KVM_REQ_PMUvcpu
 kvm_own_pmu);
  >arch | KVM_LARCH_PMU
 }
}

 void(struct  *vcpu
{
 u32 version;
 u64 steal;
 gpa_t gpa;
 struct kvm_memslots write_csr_perfctrl3context-[3)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 struct kvm_steal_time __
 truct *ghc;

 ghc = &vcpu->arch.st.cache;
 gpa =vcpu-arch.guest_addrjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
if!gpaKVM_STEAL_PHYS_VALID)
  return

 gpa &= KVM_STEAL_PHYS_MASK;
 slots = kvm_memslots(vcpu->kvm);
 if (slots->generation !=  kvm_read_clear_hw_gcsrcsr;
 i    >arch
 >gpa;
 kvm_restore_hw_gcsr,LOONGARCH_CSR_PERFCNTR1
  }
 }

 st = (struct kvm_steal_time __user  (csr);
 unsafe_get_user, &>version);
 if(version)
  version ;/

 version +1
 unsafe_put_user(version, &st->version, (csr);
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

 unsafe_get_user
steal>. ->arch.last_steal
 vcpu->archEINVAL();
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

smp_wmb;
 version += 1;
 unsafe_put_user(version, &st-();
:
 java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
}

/*
 * 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: Index 0 out of bounds for length 0
 ;

 if (kvm_check_request(KVM_REQ_TLB_FLUSH
   /* Disable pmu access from guest */

  write_csr_gcfgread_csr_gcfg  ~SR_GCFG_GPERF;
  return RESUME_HOST;

 if (kvm_check_request(KVM_REQ_STEAL_UPDATE, vcpu))
  kvm_update_stolen_time

 return  * Clear KVM_LARCH_PMU if the guest is not using PMU CSRs when
}

static void kvm_late_check_requests(struct  *
{
 lockdep_assert_irqs_disabled(  * before entering guest VM
 if (kvm_check_request(KVM_REQ_TLB_FLUSH_GPA ))
   (vcpu->.flush_gpa= INVALID_GPA {
   kvm_flush_tlb_gpa(vcpu, vcpu->arch.flush_gpa);
   vcpu->arch.flush_gpa = 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 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
{
 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1

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

 idx = srcu_read_lock(&vcpu->kvm->srcu);
 = kvm_check_requests);
  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

  u32;
}

/*
 * 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  struct kvm_steal_timekvm_steal_time _user*;
{
 int

  {
  ret kvm_enter_guest_check);
 eturn
   ;

 /
   * Handle vcpu timer, interrupts, check requests  if (kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, gpa   ghc-    }
   * check  if (version  version 
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 local_irq_disable(;
  kvm_deliver_intr);
  kvm_deliver_exception((stealst-steal);
 /* Make sure the vcpu mode has been written */
  smp_store_mb(vcpu->mode, IN_GUEST_MODE);
  kvm_check_vpid(vcpuunsafe_put_user, st-,out;
  kvm_check_pmu(vcpu);

  /*
 * 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_requestsvcpu
  >arch = csr_read64LOONGARCH_CSR_EENTRY;
  /* Clear KVM_LARCH_SWCSR_LATEST as CSR will change when enter guest */mark_page_dirty_in_slot>, >memslot(ghc-);
  vcpu-

 if((vcpu|())java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   kvm_lose_pmu(vcpu);
   /* make sure the vcpu mode has been written */
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   local_irq_enable();
  
  }
 } while (ret != RESUME_GUEST);

 return ret;
}

/*
 * Return 1 for resume guest and "<= 0" for resume host.
 */
static int kvm_handle_exit(struct kvm_run *run, struct kvm_vcpu *vcpu)
{
 int ret   vcpu-arch =0  *Drop forthis vCPU/
 longestat=vcpu-arch;
 u32   return RESUME_HOST
 u32 ecode = (estat if (kvm_check_request(KVM_REQ_STEAL_UPDATE vcpu

 vcpu- RESUME_GUEST

 /* Set a default exit reason */void kvm_late_check_requests( kvm_vcpuvcpu
 ();

 (vcpu

 guest_timing_exit_irqoff();
 guest_state_exit_irqoff();
 local_irq_enable();

 trace_kvm_exit(vcpu, kvm_flush_tlb_gpa, >arch);
 if (ecode) {
  ret = kvm_handle_fault(vcpu vcpu-.flush_gpaINVALID_GPA;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  WARN(!intr, * Run with irq enabled and  * Return: RESUME_GUEST if we should *         RESUME_HOST  if we should exit to *         < 0 if we should exit to userspace, where the *         indicates an error java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ret
 }

 if (ret == RESUME_GUEST)
  ret = kvm_pre_enter_guest(vcpu);

 if (ret != RESUME_GUEST = kvm_check_requests);
  local_irq_disable();
 ret
 }


 guest_state_enter_irqoff * Called with  *
 trace_kvm_reenter(vcpu);

 return RESUME_GUEST *         Others if we should exit tojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ifret RESUME_GUEST)

int kvm_arch_vcpu_runnable(struct kvm_vcpu *vcpu)
 
 return !!(vcpu->arch.   * check vmid before  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  vcpu->arch.mp_state.mp_state == KVM_MP_STATE_RUNNABLE;
}

int kvm_arch_vcpu_should_kick(structsmp_store_mb>modeIN_GUEST_MODE
{
 return kvm_vcpu_exiting_guest_modevcpu=IN_GUEST_MODE
}

bool   * Called after function    * Since it updates CSR   * and it may also clear
{
  long;

 ();
 val (kvm_request_pending(vcpu xfer_to_guest_mode_work_pending( 
 preempt_enable

 return (val  smp_store_mb>mode, );
}

#ifdef}
unsigned kvm_arch_vcpu_get_ip kvm_vcpu*)
{
  vcpu-.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 intret= RESUME_GUEST
}
#endif

boolkvm_arch_vcpu_preempted_in_kernelstruct *vcpu
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

vm_fault_t(vcpu;
{
 return VM_FAULT_SIGBUS;
}

int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu *vcpu,
      structkvm_translationtr
{
 returnEINVAL
}

int kvm_cpu_has_pending_timerstruct *vcpu
{
 int ret;

 /* Protect from TOD sync and vcpu_load/put() */
 preempt_disable;
 retkvm_pending_timer) |
  (LOONGARCH_CSR_ESTAT 1< );
 preempt_enable(ifret RESUME_GUEST

 return retifret ) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

int kvm_arch_vcpu_dump_regs(struct kvm_vcpu * (vcpu
{
 int }

 kvm_debug("vCPU Register Dump:\n");
 kvm_debug("\ = 0x%8lx\" vcpu-.pc)
kvm_debug\tExceptions8\n, cpu-.irq_pending

 for
("\%2d:%0lx%8 %08lx 0lxn",i,
  vcpu-arch[i],vcpu-.gprs 1,
         vcpu->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

  returnkvm_vcpu_exiting_guest_mode)=IN_GUEST_MODEjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    kvm_read_hw_gcsrjava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    kvm_read_hw_gcsr();

 kvm_debug("\tERA: 0x%08lx\n", al (LOONGARCH_CSR_CRMD

 eturn
}

tate(struct *vcpu,
    struct kvm_mp_state long(struct *vcpu
{
 *

 return 0 * Returns true if a Performance Monitoring Interrupt * arrived in guest context.  For LoongArch64, if PMU * any event that arrives while a vCPU *
}

m_arch_vcpu_ioctl_set_mpstate  *vcpu
    struct java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
{
 int ret ;

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  KVM_MP_STATE_RUNNABLE
  vcpu->arch.mp_state = *mp_state
  break
 default:
 ret-;
 }

 return ret;
}

int kvm_arch_vcpu_ioctl_set_guest_debug(struct
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 if
 i ret

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

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

staticint vm_arch_vcpu_dump_regs  *vcpu
{
 int cpuid;
 struct kvm_phyid_map *map;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (val> KVM_MAX_PHYID)
  return -EINVAL;

 map = vcpu->kvm->arch.phyid_map;
 cpuid =  kvm_debug(\tExceptions 0n",vcpu->.irq_pending);

 spin_lock kvm_debug\%2:%lxlx0 0lx, ,
if(cpuid < VM_MAX_PHYID&map->phys_mapcpuidenabledjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 /* Discard duplicated CPUID set operation */
  if (cpuid == val) {
   spin_unlock(&vcpu->kvm->arch.phyid_map_lock);
   return 0;
 }

  /*
 * CPUID is already set before
 * Forbid changing to a different CPUID at runtime
 */
  spin_unlock(&vcpu-("tERA x0lxn, (LOONGARCH_CSR_ERA);
  return -EINVAL;
 }

 if (map->phys_map[val].enabled) {
  /* Discard duplicated CPUID set operation */ 0;
int (structkvm_vcpuvcpu
  (&>kvm-.phyid_map_lock
   return 0;
  }

  /*
 * New CPUID is already set with other vcpu
 * Forbid sharing the same CPUID between different vcpus
 */
  spin_unlock(&vcpu->kvm->arch.phyid_map_lock)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  et0
  (>mp_state

 >arch  mp_state
map-[]. = ;
 map->phys_map:
   =-INVAL

 return
}

static inline void kvm_drop_cpuid(struct kvm_vcpu *    *)
{
  -;
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 struct

 map
  =(csr);

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

 spin_lock(&vcpu->kvm->{
 if (map->phys_map[cpuid].enabled) {
  intcpuid;
  map-struct kvm_phyid_mapmap
 kvm_write_sw_gcsrcsr,LOONGARCH_CSR_CPUID);
 }
 spin_unlock>arch);
}

structkvm_vcpu kvm_get_vcpu_by_cpuid kvm, int)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

ifcpuid>K)
  return NULL;/

 map = kvm-  ( == val){
  (!ap->[cpuid.enabled
 return NULL;

 return map->phys_map set before
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned long gintc;
 struct loongarch_csrs *csr = vcpu->arch.csr;

 if get_gcsr_flag) &INVALID_GCSR
   java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if (  /* Discard duplicated CPUID set operation */
  preempt_disable();
  vcpu_load(vcpu);
  /*
 * Sync pending interrupts into ESTAT so that interrupt
 * remains during VM migration stage
 */
  kvm_deliver_intr
  vcpu->arch.aux_inuse &= ~KVM_LARCH_SWCSR_LATEST;
  vcpu_put(vcpu);
  preempt_enable  

  /* ESTAT IP0~IP7 get from GINTC */
 returnEINVAL
  *val
  return 0;
 }

 /*
 * Get software CSR state since software state is consistent
 * with hardware for synchronous ioctl
 */
 *val = kvm_read_sw_gcsr(csr, id);

 return 0;
}

static int pin_unlockvcpu->arch);
{
 int retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct loongarch_csrs

 if kvm_phyid_map;
n EINVAL

 if (id =vcpu->arch;
 cpuid =kvm_read_sw_gcsr, LOONGARCH_CSR_CPUIDjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

 if (ids(&vcpu->.phyid_map_lock
 java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  = val )&0;
   map-phys_mapcpuid = false

  gintc = val & ~(0xffUL << 2);
  kvm_set_sw_gcsrspin_unlock>kvm-.);

 return;
 }

 kvm_write_sw_gcsrcsrid);

 /*
 * After modifying the PMU CSR register value of the vcpu.
 * If the PMU CSRs are used, we need to set KVM_REQ_PMU.
 */
ifid  &  < ) {
  unsigned long valreturnNULL

  val = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_PERFCTRL0) |
        kvm_read_sw_gcsr
        kvm_read_sw_gcsr
        kvm_read_sw_gcsrcsrLOONGARCH_CSR_PERFCTRL3

    long;
  structloongarch_csrscsrvcpu-.csr
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ret;


staticint kvm_get_cpucfg_mask, v)
{
 if (id < 0 || id >   * remains during VM migration stage
  return -EINVAL;

 switchid {
 case LOONGARCH_CPUCFG0:
  *v = GENMASK(31, 0);
  return 0;
 case LOONGARCH_CPUCFG1:
  /* CPUCFG1_MSGINT is not supported by KVM */
  *v = GENMASK
  return 0;
 case LOONGARCH_CPUCFG2:
  /* CPUCFG2 features unconditionally supported by KVM */
  *v = CPUCFG2_FP     | CPUCFG2_FPSP  | CPUCFG2_FPDP     |
      CPUCFG2_FPVERS|CPUCFG2_LLFTP  |
      CPUCFG2_LSPW|CPUCFG2_LAM
 /*
 * For the ISA extensions listed below, if one is supported
 * by the host, then it is also supported by KVM.
 */
f ()
   *v |= CPUCFG2_LSX;
  if (cpu_has_lasx  * with hardware for synchronous ioctl
  *v =CPUCFG2_LASX
  if (cpu_has_lbt_x86 0;
  v =CPUCFG2_X86BT
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *v |= CPUCFG2_ARMBT;
  if (cpu_has_lbt_mips)
   *v |=   ret,gintc

  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 case LOONGARCH_CPUCFG3:
  *v = GENMASK(16, 0);
  return 0;
 case LOONGARCH_CPUCFG4
 case LOONGARCH_CPUCFG5:
GENMASK3,)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  return
 caseLOONGARCH_CPUCFG6
  if cpu_has_pmp
   * =GENMASK )
 
   *v =
  eturn
 ;
v=(16)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
eturn;
 case  * After modifying the PMU CSR   * If the PMU CSRs are used, we need to set KVM_REQ_PMU.
  *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;
 }
}

static int kvm_check_cpucfg(int id, u64 val)
{
 int ret;
 u64 mask  ifval )

 ret _vm_get_cpucfg_mask(, &);
 if  }
  return ret;

 if (val & ~mask)
  /* Unsupported features and/or the higher 32 bits should not be set */;
static _(int,  *vjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

 switch (switch id
  v=(31 )java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  if (!val ))
   /* Guests must have a constant timer */
   return -EINVAL;
  if ((case:
   /* Single and double float point must both be set when FP is enabled */
   -;
  if ((val &       |CPUCFG2_LLFTP |
   * LSX architecturally implies FP but val does not satisfy that */
   return -EINVAL;
  if ((val & CPUCFG2_LASX) &&   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* LASX architecturally implies LSX and FP but val does not satisfy that */
   return -EINVAL;
  return 0;
 case LOONGARCH_CPUCFG6
  if   * =CPUCFG2_LASX
   u32 host* =CPUCFG2_X86BTjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   if v=CPUCFG2_ARMBT
    i cpu_has_lbt_mips
   (valCPUCFG6_PMNUM host))
    return -EINVAL;
    (val CPUCFG6_UPM &!host&CPUCFG6_UPM
    return LOONGARCH_CPUCFG3
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return 0;
 default:
 /*
 * Values for the other CPUCFG IDs are not being further validated
 * besides the mask check above.
 */
  return  case LOONGARCH_CPUCFG16:
 }
}

static  *v = GENMASK(3  return 0;
  const   * CPUCFG bits should be zero if    * supported by   
{
 }
 6  = reg-id ;

 switch int(intid u64 )
 case i ret
 =KVM_GET_IOC_CSR_IDX>);
  ret = _kvm_getcsr(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;
 case KVM_REG_LOONGARCH_CPUCFG:
  id valmask
 i (id=0& idKVM_MAX_CPUCFG_REGS
  return-INVAL
  
   ret =-EINVAL;
  break;
 case KVM_REG_LOONGARCH_LBT:
  if (!kvm_guest_has_lbt(&vcpu->arch))
   return -ENXIO;

  switch (reg->id) {
  case KVM_REG_LOONGARCH_LBT_SCR0:
 .scr0
   break;
  case KVM_REG_LOONGARCH_LBT_SCR1
   *v = vcpu-   -;
   break if( & ) & !valCPUCFG2_FPSP|( & )))
  case KVM_REG_LOONGARCH_LBT_SCR2
   *v = vcpu->arch.lbt.scr2
  reak
 case KVM_REG_LOONGARCH_LBT_SCR3:
   *v = vcpu->arch.lbt.scr3;
   break;
  case:
   *v = vcpu- (valCPUCFG2_LASX&!valCPUCFG2_LSX
   break;
 case:
   *v = vcpu- -;
   break;
  default
t= EINVAL
   break
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  break;
 case KVM_REG_LOONGARCH_KVM:   E;
 reg- 
  case java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
   *v   EINVAL
   break;
  case KVM_REG_LOONGARCH_DEBUG_INST:
  *v = INSN_HVCL|KVM_HCALL_SWDBG
   break;
  default:
   ret = -EINVAL;
   break;
  }
  break;
 default:
  ret = -EINVAL   
  break;
 }

 return ret;
}

static int kvm_get_reg(struct kvm_vcpu *vcpu, const struct kvm_one_reg *reg)
{
 int{
 u64 v, size = reg->id & KVM_REG_SIZE_MASK;

 switch (size) {
 case KVM_REG_SIZE_U64:
  ret = kvm_get_one_reg(vcpu, u64type=reg- & KVM_REG_LOONGARCH_MASK;
  if (ret)
   return ret;
  ret = put_user(v, (u64 __user *)(long)reg->addr);
  break;
 default:
  ret = -EINVAL;
  break;
 }

 return ret;
}

static int kvm_set_one_reg(struct kvm_vcpu *vcpu,
   const struct  id = KVM_GET_IOC_CSR_IDXreg-id);
{
 ,ret=0java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   *  vcpu->arch.pucfg];

 switch   ret-;
 ;
  KVM_REG_LOONGARCH_LBT
  retifk(&vcpu-))
  break  return -ENXIO;
 caseswitch (>id{
  id *vcpu-.lbt
   :
  v=>archlbt;
break
  vcpu-:
  if (id == LOONGARCH_CPUCFG6)
   vcpu->arch.max_pmu_csrid =
     + 2*kvm_get_pmu_num&cpu-arch+1java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  break;
 case :
  if (!kvm_guest_has_lbt(&vcpu- KVM_REG_LOONGARCH_LBT_EFLAGS
  returnENXIO

  switch (reg->id) {
 ase:
   vcpu->arch * = cpu-.fpu;
   break;
  case java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 10
   vcpu->arch
   break
  case KVM_REG_LOONGARCH_LBT_SCR2s (reg-)java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  >arch.scr2;
   break;
  case KVM_REG_LOONGARCH_LBT_SCR3case:
  >arch.scr3vjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 break
  case KVM_REG_LOONGARCH_LBT_EFLAGS:
   vcpu->arch.lbt.eflagsb;
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
  case KVM_REG_LOONGARCH_LBT_FTOP = EINVAL
   vcpu- }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  default:
   ret int(struct *,   *reg
   break;
 }
  break;
 case KVM_REG_LOONGARCH_KVM:
  switch (reg->id) {
 case:
   /*
 * gftoffset is relative with board, not vcpu
 * only set for the first time for smp system
 */
   if (vcpu->vcpu_id == 0)
    vcpu->kvm->arch.time_offset = ret kvm_get_one_reg, reg&v);
   break;
  case KVM_REG_LOONGARCH_VCPU_RESET:
   vcpu->arch   ret
    retput_user, u64user()reg-addr
   memset(&vcpu-;

   /*
 * When vCPU reset, clear the ESTAT and GINTC registers
 * Other CSR registers are cleared with function _kvm_setcsr().
 */
   kvm_write_sw_gcsr(vcpu->arch.csr, LOONGARCH_CSR_GINTC,  ret-;
   kvm_write_sw_gcsr(vcpu->arch
   break
  default:
   ret =
   break;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3
  break;
 default:
  ret i id ret0
  break u64  = >id KVM_REG_LOONGARCH_MASK
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 return ret  = kvm_setcsr,id)
}

staticintkvm_set_reg kvm_vcpu, conststruct kvm_one_reg*eg
{
 int = ;
u64  = reg->d&KVM_REG_SIZE_MASK

 switch (size) {
 case KVM_REG_SIZE_U64:
   break
  if()
 return;
 break
 default: LOONGARCH_CSR_PERFCTRL0 +2 (&vcpu->rch 1
  return -EINVAL;
 }

 return(vcpureg )
}

intkvm_arch_vcpu_ioctl_get_sregs kvm_vcpu, struct *sregs
{
 return -ENOIOCTLCMD;
}

int kvm_arch_vcpu_ioctl_set_sregs;
{
 return -ENOIOCTLCMD;
}

int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu *vcpu  >arch.scr1 java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
{
 int i  KVM_REG_LOONGARCH_LBT_SCR3:

  break;
  regs->gpr case:

 regs->pc = vcpu-OcaseKVM_REG_LOONGARCH_LBT_FTOPjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

   =EINVAL
}

int(structkvm_vcpu *vcpu  kvm_regs)
{
  i;

 fori=1; i  (vcpu-.gprs +)
  vcpu->arch.gprs[i] = regs->gpr[i];

 vcpu-archgprs0 = 0 /* zero is special, and cannot be set. */
 vcpu->   /*

return 0;
}

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

 int
   kvm_device_attr)
{
 switch>attr
 case LOONGARCH_CPUCFG2 /*
case LOONGARCH_CPUCFG6:
return 0;
case CPUCFG_KVM_FEATURE:
return 0;
default:
return -ENXIO;
}

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 */
  if ((kvm-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  &(>arch & ) !val
   return -EINVAL
  kvm->arch.pv_features
  return 0;
 default
  return -ENXIO;
 }
}

static int kvm_loongarch_pvtime_set_attr(struct kvm_vcpu *vcpu,
      struct kvm_device_attr *attr)
{
 int idx, ret = 0;
 u64 gpa,   -EINVAL
 struct kvm *kvm = vcpu->kvm;

 sta intkvm_loongarch_cpucfg_has_attr kvm_vcpuvcpu,
   || attr->attr !   structkvm_device_attr *ttr)
  return -ENXIO;

 if   LOONGARCH_CPUCFG2
   -;

  ( & ~KVM_STEAL_PHYS_MASK|KVM_STEAL_PHYS_VALID
  return -EINVAL;

  (!( & KVM_STEAL_PHYS_VALID)){
  vcpu->default:
 return0
 }

 /* Check the address is in a valid memslot */
 idx = srcu_read_lock(&kvm-static int kvm_loongarch_pvtime_has_attr(struct kvm_vcpu *vcpu,
 if ({
  ret  if (!kvm_guest_has_pv_feature(vcpu, KVM_FEATURE_STEAL_TIME)
 srcu_read_unlock(&kvm->srcu, idx);

 if (!ret) {
  vcpu->arch.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  vcpu->arch.st.last_stealce_attr *attr)
  kvm_make_request(KVM_REQ_STEAL_UPDATE, vcpu{
 }

 return ret;
}

break;
           struct kvm_device_attr *attr)
{
 int ret = -ENXIO;

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

 return ret;
}

long kvm_arch_vcpu_ioctl switch (attr->attr) {
    unsigned int ioctl, unsigned long arg)
{
 case CPUCFG_KVM_FEATURE:
 struct kvm_device_attr attr;
 void __user default:
 struct kvm_vcpu * }

 /*
 * 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
 case return 0;
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct{

  r = -EFAULT;
  if (copy_from_user( case KVM_LOONGARCH_VCPU_CPUCFG:
   break;
  if (  break;
    case KVM_LOONGARCH_VCPU_PVTIME_CTRL:
   vcpu->arch.aux_inuse &= ~KVM_LARCH_HWCSR_USABLE  break;
  } else
   r = kvm_get_reg(vcpu, ®);
  break;
 }
 case KVM_ENABLE_CAP: {
  struct kvm_enable_cap cap;

  r = -EFAULT;
  if (copy_from_user(&cap struct kvm *kvm =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   break;
  r = kvm_vcpu_ioctl_enable_cap(vcpu  if (val & ~valid)
  break;
 }
 case  if (kvm->archpv_features& LOONGARCH_PV_FEAT_UPDATED)
  r = -EFAULT;
  if (copy_from_user(&attr, argp, sizeof(attr)))
   break    &&(>archpv_features) !=val
    (vcpuattr
  break;
 }
   0
   =-FAULT;
  if (copy_from_user(&attr, argp, sizeof(attr)))
   break;
  r = kvm_loongarch_vcpu_get_attr(vcpu,
  break;
 }
 case KVM_SET_DEVICE_ATTR: {
  r = -EFAULT;
  if (copy_from_user(&attr, argp, sizeof(attr)))
   break;
  r = kvm_loongarch_vcpu_set_attrvcpu, &);
  break;
 }
 default:s kvm* = vcpu-;
  r =
  breakjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 }

 return r;
}

int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu *vcpu, struct  return -;
{
 inti= ;

 fpu-> fpu->fcc
 fpu->fcsr = vcpu-archfpu.fcsr
 for i =0 i < NUM_FPU_REGSi+)
  memcpy(&fpu->fpr[i], &vcpu->arch.fpu.fpr[i], FPU_REG_WIDTH / 64);

 eturn;
}

int kvm_arch_vcpu_ioctl_set_fpu 0;
{
 int i = 0;

 vcpu-java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 vcpu->arch.fpu.fcsr = fpu->fcsr idx=srcu_read_lockkvm->srcu);
 for (i = 0; i < NUM_FPU_REGS i++)
  memcpy(&vcpu->arch.fpu.fpr[i], &fpu->fpr[i], FPU_REG_WIDTH / 64);

 return 0;
}

#ifdef CONFIG_CPU_HAS_LBT
int kvm_own_lbt(struct kvm_vcpu *vcpu)
{
 if (!kvm_guest_has_lbt(&vcpu->arch))
  return -EINVALif(ret{

preempt_disable;
 if (!( kvm_make_requestKVM_REQ_STEAL_UPDATEvcpu
  set_csr_euen(CSR_EUEN_LBTEN);
  _restore_lbtreturnret
 }
 }
 preempt_enable();

 return 0;
}

static void kvm_lose_lbt(struct kvm_vcpu *vcpu)
{
 preempt_disable();
 if (vcpu->arch.aux_inuse & KVM_LARCH_LBTjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  _save_lbt(&vcpu- witchattr-) {
  clear_csr_euen case KVM_LOONGARCH_VCPU_CPUCFG
u-archaux_inuse= KVM_LOONGARCH_VCPU_PVTIME_CTRL
 }
 preempt_enable();
}

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

static void kvm_check_fcsr_alive
{
if>. &KVM_LARCH_FPU java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  if (vcpu->arch kvm_vcpuvcpu  filp->private_datajava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    * Only software CSR should be modified
  kvm_check_fcsr  * If any hardware CSR register is modified, vcpu_load/vcpu_put pair
 }
}  * to other vcpus, other vcpus need reload CSR registers.
#else
static inline void kvm_lose_lbt(struct kvm_vcpu *vcpu) { }
static inline void kvm_check_fcsr(struct  * aux_inuse flag and reload CSR registers form software.
static inline void kvm_check_fcsr_alive(struct kvm_vcpuc KVM_SET_ONE_REG
#endif

/* Enable FPU and restore context */
void  -;
{
 preempt_disable

 /*
 * Enable FPU for guest
 * Set FR and FRE according to guest context
 */
  r=(vcpu);
break

 kvm_restore_fpuvcpu-arch);
 struct cap
 trace_kvm_aux(vcpu, KVM_TRACE_AUX_RESTORE

 preempt_enable();
}

#ifdef CONFIG_CPU_HAS_LSX
/* Enable LSX and restore context */
int kvm_own_lsx(struct kvm_vcpu *vcpu)
{
 if(!vm_guest_has_fpu&>arch| k(&vcpu-archjava.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  return -INVAL;

 preempt_disable();

 /* Enable LSX for guest */
 kvm_check_fcsr(vcpu, vcpu->arch.fpu.fcsr);
 set_csr_euen
 switch (vcpu->arch.aux_inuse  KVM_GET_DEVICE_ATTR java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
caseKVM_LARCH_FPU
  /*
 * Guest FPU state already loaded,
 * only restore upper LSX state
 */
  _restore_lsx_upper(&vcpu->arch.fpu);
  break;
 default:
  /* Neither FP or LSX already active,
 * restore full LSX state
 */
  kvm_restore_lsx(&vcpu->arch.fpu caseKVM_SET_DEVICE_ATTR: {
  break;
 }

 trace_kvm_aux r =kvm_loongarch_vcpu_set_attrvcpu,&);
 vcpu-archaux_inuse | KVM_LARCH_LSX|KVM_LARCH_FPU
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2

 return 0;
}
#

#ifdef CONFIG_CPU_HAS_LASX
/* Enable LASX and restore context */
int {
{
 if (!kvm_guest_has_fpu(&vcpu->arch) || !kvm_guest_has_lsx(&vcpu-int i  ;
  returnfpu-> = >archfpu.cc

 preempt_disable();

 kvm_check_fcsr  (i =0;i <NUM_FPU_REGSi+)
 memcpyfpu-[i] &cpu->.fpu[i],FPU_REG_WIDTH 4;
 switch (vcpu->arch.aux_inuse & (KVM_LARCH_FPU | KVM_LARCH_LSX)) {
 case KVM_LARCH_LSX:
 case KVM_LARCH_LSX | KVM_LARCH_FPU:
 /
  _restore_lasx_upper(&vcpu->arch.fpu);
  
 caseKVM_LARCH_FPU
  /* Guest FP state already loaded, only restore upper LSX & LASX state */
  _ >archfpu = >fcsr
  _fori=0  < ; i+)
 break
 default:
  /* Neither FP or LSX already active, restore full LASX state */
  kvm_restore_lasx(&vcpu->arch.fpu);
  break;
 }

 trace_kvm_aux (kvm_guest_has_lbt(vcpu-))
>arch. |=  | KVM_LARCH_LSX|KVM_LARCH_FPU
 preempt_enable();

 return 0;
}
#endif

/* Save context and disable FPU */
void kvm_lose_fpu(struct kvm_vcpu *vcpu)
{
 preempt_disable();

 kvm_check_fcsr_alive
 >. & ){
  kvm_save_lasx(&vcpu->arch.fpu);
  vcpu->arch }
  trace_kvm_aux(vcpu,  reempt_enable;

  /* Disable LASX & LSX & FPU */
  clear_csr_euen(CSR_EUEN_FPEN | CSR_EUEN_LSXEN
 }static kvm_lose_lbtstruct *vcpu
  kvm_save_lsx(&vcpu-()
cpu-. & (KVM_LARCH_LSX );
  trace_kvm_auxsave_lbtarch

  /* Disable LSX & FPU */
  (  );
 } else if (vcpu->arch.aux_inuse & KVM_LARCH_FPU) {
 (&>archfpu
  vcpu->arch.aux_inuse &= ~KVM_LARCH_FPU;
  trace_kvm_aux(staticvoid(structkvm_vcpuvcpu  long)

  /* Disable FPU */
  clear_csr_euen(CSR_EUEN_FPEN  * If TM is enabled, top register save/restore will
 }
 kvm_lose_lbt)

 preempt_enable();
}

int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *
{
 int intr  if (vcpu-archaux_inuse& KVM_LARCH_LBT)

 if (intr > 0)
  kvm_queue_irq(vcpu, intr);
 else if (intr < 0)
  kvm_dequeue_irq, -);
 else {
  kvm_errjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  return -EINVAL;
 }

 kvm_vcpu_kick(vcpu);

 return 0;
}

long kvm_arch_vcpu_async_ioctl(struct file *filpjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          int ioctl unsignedlong arg
{
 void __user *argppreempt_disable);
 struct kvm_vcpu *vcpu = filp-

 if (ioctl  * Set FR and FRE according to guest context
  struct kvm_interrupt irq kvm_check_fcsrvcpu vcpu-.fpu.fcsr;

  if (copy_from_user(&irq, argp, sizeof(irq)))
   return set_csr_euen(CSR_EUEN_FPEN;

  kvm_debug" :irq: dn, vcpu->, _func__, irq;

  return kvm_vcpu_ioctl_interrupt(vcpu, &irq);
 }

 return-;
}

int kvm_arch_vcpu_precreate(struct kvm *kvm, unsigned int id)
{
 return0;
}

int kvm_arch_vcpu_create(structintkvm_own_lsxstructkvm_vcpu *cpu
{
 unsigned long timer_hz;
 struct loongarch_csrs *csr;

 vcpu->arch(&vcpu-arch) | !kvm_guest_has_lsx&vcpu-))
  returnEINVAL;

 (&>archswtimer, ,
        HRTIMER_MODE_ABS_PINNED_HARD

 /* Get GPA (=HVA) of PGD for kvm hypervisor */(vcpu>archfpu.fcsr);
 vcpu->arch.kvm_pgd = __pa(vcpu-  (vcpu-archaux_inuse&KVM_LARCH_FPUjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

 /*
 * Get PGD for primary mmu, virtual address is used since there is
 * memory access after loading from CSR_PGD in tlb exception fast path.
 */
 vcpu-break

 cpu-.handle_exit kvm_handle_exit;
vcpu-.guest_eentry= unsignedlong)kvm_loongarch_ops->exc_entry;
 ->archcsr=kzallocsizeofstruct loongarch_csrs GFP_KERNEL);
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 21
  return

 /*
 * All kvm exceptions share one exception entry, and host <-> guest
 * switch also switch ECFG.VS field, keep host ECFG.VS info here.
 */
 vcpu->arch.host_ecfg = (read_csr_ecfg() & CSR_ECFG_VS);

 /* Init */
 vcpu->arch.last_sched_cpu = -1;

 /* Init ipi_state lock */
 spin_lock_init(&vcpu->arch.}

 /*
 * Initialize guest register state to valid architectural reset state.
 */
 timer_hz = calc_const_freq();
 kvm_init_timer(vcpu kvm_own_lasxstruct kvm_vcpu *vcpu)

 /* Set Initialize mode for guest */
 csr = vcpu->arch.csr;
 kvm_write_sw_gcsr if(!vm_guest_has_fpu&vcpu-arch | !vm_guest_has_lsx&>arch) ||!kvm_guest_has_lasx(&vcpu-))

 /* Set cpuid */
 kvm_write_sw_gcsr(csr, LOONGARCH_CSR_TMID, vcpu->vcpu_id);
 kvm_write_sw_gcsr(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 csr->switch vcpu-.aux_inuse KVM_LARCH_FPU KVM_LARCH_LSX{

 return 0;
}

void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu)
{
}

void kvm_arch_vcpu_destroy(struct kvm_vcpu(>arch)
case:
 int  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 struct kvm_context *context;

 hrtimer_cancelbreak
free_memory_cache&>archmmu_page_cache
 kvm_drop_cpuid(vcpu)  /* Neither FP or LSX already active, restore full LASX state */FP LSXalreadyactive,restore LASX */
 kfree(vcpu->arch.csr);

 /*
 * 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) {
  contextpreempt_enable;
  if (context->last_vcpu == vcpu)
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }
}

static int _
{
 migrated
 struct kvm_context *context reempt_disablejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 struct loongarch_csrscsr=>archcsr

 /*
 * Have we migrated to a different CPU?
 * If so, any old guest TLB state may be stale.
 */
 migrated   /* Disable LASX & LSX & FPU */

 /*
 * Was this the last vCPU to run on this CPU?
 * If not, any old guest state from this vCPU will have been clobbered.
 */
 context = per_cpu_ptr(vcpu->kvm->arch.vmcs, cpu);
 if (migrated || (context->last_vcpu != vcpu))
  vcpu->arch.aux_inuse &= ~KVM_LARCH_HWCSR_USABLE  kvm_save_lsx(&cpu-arch.fpu);
 context-last_vcpu=vcpu

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

 /* Restore hardware PMU CSRs */
 kvm_restore_pmu>archaux_inuse &KVM_LARCH_FPU

 /* Don't bother restoring registers multiple times unless necessary */
  (vcpu-arch. & KVM_LARCH_HWCSR_USABLE
  return 0 trace_kvm_aux, KVM_TRACE_AUX_SAVE KVM_TRACE_AUX_FPU);

 write_csr_gcntc(ulong)vcpu->arch);

 /* Restore guest CSR registers */
 kvm_restore_hw_gcsr(csrkvm_lose_lbt();
 kvm_restore_hw_gcsr(csr, p()
 kvm_restore_hw_gcsr(
_)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 kvm_restore_hw_gcsr
 kvm_restore_hw_gcsr(, );
 kvm_restore_hw_gcsr(csr, k(vcpu);
 kvm_restore_hw_gcsr if < )
 vm_restore_hw_gcsr, LOONGARCH_CSR_EENTRY
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBIDX);
 kvm_restore_hw_gcsr,LOONGARCH_CSR_TLBEHI
  returnEINVAL;
 kvm_restore_hw_gcsr java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 (csrLOONGARCH_CSR_ASID;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PGDL);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PGDH);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PWCTL0);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_PWCTL1
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_STLBPGSIZE);
 kvm_restore_hw_gcsrcsr LOONGARCH_CSR_RVACFG
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_CPUID);
 (csr LOONGARCH_CSR_KS0);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS1);
 kvm_restore_hw_gcsr(csr,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 vm_restore_hw_gcsrcsrLOONGARCH_CSR_KS3;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS4);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS5java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS6);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_KS7);
 kvm_restore_hw_gcsrcsr LOONGARCH_CSR_TMID);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_CNTC);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRENTRY);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRBADV);
 kvm_restore_hw_gcsr(csr,  return kvm_vcpu_ioctl_interruptvcpu irq
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRSAVE);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TLBRELO0
kvm_restore_hw_gcsr, );
 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
 kvm_restore_hw_gcsr(csr
 kvm_restore_hw_gcsrcsr, LOONGARCH_CSR_DMWIN0;
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN1);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN2);
 kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_DMWIN3);
 kvm_restore_hw_gcsrunsignedlong ;

 /* 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_llbctlCSR_LLBCTL_WCLLB

 vcpu- * Get GPA (=HVA) of PGD for kvm hypervisor */

 return 0;
}

void kvm_arch_vcpu_load(
{
 unsigned long  * Get PGDfor primary, virtualaddressisused since there is

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

static intvcpu-arch = ( long>;
{
 struct loongarch_csrs *csr  if (vcpu-.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. >.  1
  goto out;

 kvm_save_hw_gcsr(csr (&vcpu-arch.lock
 kvm_save_hw_gcsr(csr /*
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-

 return 0;
}

void kvm_arch_vcpu_put(struct kvm_vcpu context = per_cpu_ptrvcpu-kvm->arch, cpu);
{
 int cpu;
 unsigned long flags;

 local_irq_save(flags);
 cpu = smp_processor_idkvm_restore_timer)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
 vcpu->arch.last_sched_cpujava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 _kvm_vcpu_put(vcpu,  (()vcpu->arch.);
 local_irq_restore(flags);
}

int kvm_arch_vcpu_ioctl_run(kvm_restore_hw_gcsr, );
{
 int r = -EINTR;
 struct kvm_run *run = vcpu->k(csr);

k(, );
  if (!vcpu->mmio_is_write(,);
  (vcpu)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  vcpu->mmio_needed kvm_restore_hw_gcsrcsr);
 }

 (>exit_reason
 case KVM_EXIT_HYPERCALL:
  kvm_complete_user_service(vcpu, run);
  break;
 case KVM_EXIT_LOONGARCH_IOCSR:
  if (!run->iocsr_io. (csrLOONGARCH_CSR_KS0
   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_activatevcpu
 r =  kvm_restore_hw_gcsrcsr, LOONGARCH_CSR_KS7);
 if (r !=  kvm_restore_hw_gcsr(, LOONGARCH_CSR_TMID);
  goto out;

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

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

 return r;
}