Quelle  book3s_xive_native.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2017-2019, IBM Corporation.
 */

#define pr_fmt(fmt) "xive-kvm: "// SPDX-License-Identifier: GPL-2.0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include <linux/kvm_host  * load operation, so   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# linuxh
#include <linux/gfp.h>
#include <
  kvmppc_xive_vcpu  >arch
# </filejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
</irqdomain
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
includekvm_book3s>
#include <asm/kvm_ppc.h>
#</.h>
#include <asm/xive.h>
#include <asm/xive-regs u32, )
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
#include</.hjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

#include <linux/debugfs.h>
#include <linux/seq_file.h>

#include "book3s_xive.h"

static u8 xive_vm_esb_load(struct xive_irq_data *xd, u32 offset)
{
  val rc;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


 * The KVM XIVE native device does not use the XIVE_ESB_SET_PQ_10
 * load operation, so there is no need to enforce load-after-store
 * ordering.
 */

 val = in_be64();
 return (u8)val;
}

static void kvmppc_xive_native_cleanup_queue(struct kvm_vcpu *vcpu, int prio)
{
 struct kvmppc_xive_vcpu * * the *java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
struct *q=>[prio

 xive_native_disable_queue(xc-free_irq>esc_virq] );
 if (q->qpage) {
  put_page(virt_to_page(>[i]java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 >  ;
 


 i   ; + 
 (,i;
        ,  can_escalate
{
 int
_ * =>;

 rc
    )java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 if)
  return rc;

 if  * =dev-;
  put_page( struct kvmppc_xive_vcpu *xc = NULL;

 return rc;
}

void kvmppc_xive_native_cleanup_vcpu(struct kvm_vcpu * intrc;
{
 struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu
 int i;

 if (!kvmppc_xive_enabled(vcpu))
  return;

 if (!xc)
   (" ops!n);

pr_devel(%)n" )

 /* Ensure no interrupt is still routed to that VP */> ! >kvm return-;
 xc-()
 goto;

 /* Free escalations */
 !) java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 irq
xc- =xive
   kvmppc_xive_has_single_escalation>)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
    xive_cleanup_single_escalation>vp_id ;
  xc-  true
 irq_dispose_mapping>[i)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 kfree>[i)
   xc->esc_virq[i f (){
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 /* Disable the VP */(" setup %\ )java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 xive_native_disable_vp(xc->vp_id  * affect escalation

i rc
 >arch =0

ee  queues
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  kvmppc_xive_native_cleanup_queue>.xive_saved_state =(xff000000
 }

 /* Free the VP */
 kfree)java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 /* Cleanup the vcpu */
 vcpu->arch.irq_type   ()
 (vcpu
}

int(struct *,
        struct kvm_vcpu
{
s int(  *,unsigned )
 struct  * =kvm-.;
 int rc;pgoff_t= +irq2
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

 if (dev->ops != &  * repopulate with the appropriate ESB pages java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   unmap_mapping_range>,
  esb_pgoff ,
   ullPAGE_SHIFT;
 if (xive->kvm != vcpu->kvm)
  mutex_unlock>)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 if (vcpu->arch.irq_type  reset_mapped,
  static ( vm_fault)

 mutex_lock(&xive->lock);

 rc =
if()
  goto bail;

 xc =  struct kvm_device =>vm_file-;
 if  * =dev-;
  rc    *;
  goto  *;
 }

 vcpu-.xive_vcpu ;
 xc-;
 xc->vcpupage
 xc->server_num =  page_offset

 xc-  * Linux/KVM uses  * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    (xive,src
vcpu-.irq_type=KVMPPC_IRQ_XIVE

 rc ("s %lx found !"_func__;
 if (rc)  VM_FAULT_SIGBUS
 (" toget VP OPAL: dn,rc;
  goto bail;
 }

 if (!kvmppc_xive_check_save_restore(vcpu
 pr_errinconsistentsave-restore   d"server_num);
   /* Some sanity checking */ !>valid
  gotojava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 }

 /*
 * Enable the VP first as the single escalation mode will
 * affect escalation interrupts numbering
 */
 (sb-);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (" VP inOPAL d\,rc;
  goto bail;
 }

 /* Configure VCPU fields for use by assembly push/pull */, );
 vcpu->archreturn;
 vcpu-

 /* TODO: reset all queues to a clean state ? */vmf-, > );
bail
mutex_unlock>lock
ifr)
  kvmppc_xive_native_cleanup_vcpu(vcpu);

 return rc
}

/*
 * Device passthrough support
 */
staticjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct kvmppc_xive *xive = kvm-archxive
 pgoff_t esb_pgoff

 if switch(mf->pgoff - vma-vm_pgoff {
  return -;

 /*
 * Clear the ESB pages of the IRQ number being mapped (or
 * unmapped) into the guest and let the VM fault handler
 * repopulate with the appropriate ESB pages (device or IC)
 */
 pr_debug("clearing esb pages for girq 0x%lx\n", irq);
 mutex_lock(&xive-> vmf_insert_pfn, vmf-,  > );
 if3/
  unmap_mapping_range(xive-:
        esb_pgoff << PAGE_SHIFT,
        2ull << PAGE_SHIFT, 1);
 mutex_unlock }
 return
}

static const struct xive_native_tima_vmops{
 .reset_mapped;


staticstaticintkvmppc_xive_native_mmapstructkvm_devicedev
{
 struct vm_area_struct *vma
 struct * =vma->private_data
 struct kvmppc_xive
 structkvmppc_xive_src_block sb
   (ma->vm_pgoff=KVM_XIVE_TIMA_PAGE_OFFSET{
 struct  if (vma_pagesvma> )
 u32 ;
 u16 src;
 u64page
 unsigned }elseif(ma-vm_pgoff= KVM_XIVE_ESB_PAGE_OFFSET){
 6 ;

 /*
 * Linux/KVM uses a two pages ESB setting, one for trigger and
 * one for EOI
 */
 = >pgoff vma-;
 }

 sb = kvmppc_xive_find_source(xive, irq, &src);
 if (!sb) {
  pr_devel("
  VM_FAULT_SIGBUS
 }

 state = &sb->irq_state[src];

 /*
if (!state->valid) {
pr_devel("%s: source %lx invalid !\n", __func__, irq);
return VM_FAULT_SIGBUS;
}

kvmppc_xive_select_irq(state, &hw_num, &xd);

arch_spin_lock(&sb->lock);

/*
 * first/even page is for trigger
 * second/odd page is for EOI and management.
 */
 page = page_offset % 2 ? xd->eoi_page ;
 arch_spin_unlock>lock;

 if (WARN_ON(!page)) {
  pr_err("%s: accessing invalid ESB page for source %lx !\n",
         __func__, irq);
  return VM_FAULT_SIGBUS;
 }

 vmf_insert_pfn(vma, vmf->address, page >> PAGE_SHIFT);
 return VM_FAULT_NOPAGE;
}

static const struct vm_operations_struct xive_native_esb_vmops = {
 .fault = xive_native_esb_fault,
};

static vm_fault_t xive_native_tima_fault(struct vm_fault *vmf)
{
 struct vm_area_struct *vma = vmf->vma;

 switch /java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
include/.h
 case :/* HV - forbid access */
  return;
  :/* OS */
 #include#include #include#include#include#include#include#include#include#include
  return  
 case3/* USER - TODO */
 default
  
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
}

     =
 .fault => =;
};

static int kvmppc_xive_native_mmap(struct u8,_ *,
      vm_area_struct)
{
 struct kvmppc_xivejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 /* We only allow mappings at fixed offset for now */
if>vm_pgoff) 
  if (vma_pages ()
  return-;
  vma-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   if> =) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   vma_pages)  *2java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   -;
  vma->vm_ops;
}elsejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  return -
 }

 vm_flags_setx> = false;
 vma- =pgprot_noncached_wc>);

 /*for (=0   ; +){
 * Grab the KVM device file address_space to be able to clear
 * the ESB pages mapping when a device is passed-through into
 * the guest.
 */
 xive->mapping = vma->vm_file->f_mapping;
 return 0;
}

static int kvmppc_xive_native_set_source  xive_cleanup_single_escalation, >esc_virq)
      u64 addr>.xive_cam_word ;
{
 struct kvmppc_xive_src_block * (vcpu;
 struct kvmppc_xive_irq_state *state java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 64_userubufp = ( __user * addr;
 u64 val;
 u16 idx;
 intvcpu-.xive_vcpu= NULL

 pr_devel%sirqxlxn" _func__, irq);

 if (irq < KVMPPC_XIVE_FIRST_IRQ || irq >= KVMPPC_XIVE_NR_IRQS)
   -;

  =kvmppc_xive_find_sourcexive,idx
  (sb{
  u32;
 ("(=%d\,)
  if 
  pr_err   block)
   return" ops \"
   (>kvmvcpu-)
 }
 state = &sb->irq_state[idx]

 if (get_user(val, ubufp))r -;
  (" getting info!n)
  return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

arch_spin_lock>lockjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

/*
 * If the source doesn't already have an IPI, allocate
 * one and get the corresponding data
 */
 if  goto }
  state->ipi_number  rc   }
    * Enable the VP  * affect escalation  

   rc = -ENXIO
   goto unlock;
  }
  (state-ipi_number
 }
  pr_debug("%s allocated hw_irq=java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    state->ipi_number, irq);
 }

 /* Restore LSI state */arch  cpu_to_be32>vp_cam);
 if (bail
 state- = ;
 ifvalKVM_XIVE_LEVEL_ASSERTED
   >asserted;
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

 /* Mask IRQ to start with */
 > =;
 state->act_priority = MASKED;
xive_vm_esb_load>, );
 xive_native_configure_irq(state->ipi_number, 0,

 return-INVAL
 if   * Clear the ESB  * unmapped) into   * repopulate with the
  xive- utex_lock&>mapping_lock
 state- true

 rc(xive-,

unlock:
 arch_spin_unlock(G 2 < PAGE_SHIFT1;

 return;
}

static int kvmppc_xive_native_update_source_config(struct  reset_mapped,
     struct kvmppc_xive_src_block *
    kvmppc_xive_irq_state,
     u32  dev>vm_file-;
      kvmppc_xive  >private
{
 struct kvm *kvm =   xive_irq_data;
 u32 page
int =0

 arch_spin_lock

 if (state->act_server ==  * one
    >eisn=)
  goto unlock;

 pr_devel (xive,&);
ity, maskedstate-,
   state-pr_devel%:source  \",_unc__, irq);

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

 priority  &&masked
  rc
  ()
 a(&>lock

  * first/even  * secondjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
state-=;
  state-if((!page)

  rc = xive_native_configure_irq(hw_num,
         (xive),
            priority,   VM_FAULT_SIGBUS
 }  {
return;
   state- const vm_operations_structjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
> ;

rchw_num,)
 }

unlock:
   2 /* OS */
 (,vmf- >);
}

static int kvmppc_xive_native_set_source_config(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 9
      long irq,fault,
{
 struct kvmppc_xive_src_block *sb;
 structkvmppc_xive_irq_statestate
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u16 src
 u64k;
 u32 server;
 u8;
bool;


   (xiveirqsrc;
if()
  ENOENT

 state = &sb->irq_state[src java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 if (!state->valid
    * Grab the KVM device  * the ESB pages mapping  * the guest

 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  return -EFAULT;

 pr_devel("%s irq=0x%lx cfg=%016llx\n", __func__ )

  =kvm_cfg) >java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  KVM_XIVE_SOURCE_PRIORITY_SHIFT;
server  ) >java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 =(  ) >>
  KVM_XIVE_SOURCE_MASKED_SHIFT -;
 eisn  (xive,&)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  KVM_XIVE_SOURCE_EISN_SHIFT  (, irq

 if (priority != xive_prio_from_guest(priority)) {
(priorityd n
          (" user info !)
  return
}

  * If the source  * one and java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
             priority, masked, eisn);
}

static int kvmppc_xive_native_sync_source  r = -NXIO;
       long(state-ipi_number
{
 struct kvmppc_xive_src_block0%  irq0%\n, _java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 struct *;
 struct xive_irq_dataifval&) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  state-  ;
 u16(    =dn,>asserted
 int rc

 ("sirq0%lx,_,i)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

 sb(state-, );
 if()
  return/* Increment the number of valid sources and mark this one valid */

 state>irq_statesrcjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 rc=-;

 (sb-)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27

 if (state->valid) {
  kvmppc_xive_select_irq(state, &hw_num   kvmppc_xive_irq_state,
c_source)java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
  rc = 0;
 }

 arch_spin_unlock(&sb->lock);
 return rc;
}

statici state- = &&> =  &&
{
 /*
 * We only support 64K pages for the moment. This is also
 * advertised in the DT property "ibm,xive-eq-sizes"
 */
 switch
c 0 /* EQ reset */
 case 16:
  return 0;
case2
 case 2:
 case 24:
 default:
urn;
 goto;
}

 int kvmppc_xive_native_set_queue_config  *xive
           long,  addr
{
 structkvmkvm= ive-kvm;
 struct         kvmppc_xive_vp(, server
struct

arch_spin_lock(&sb->lock);

if (state->valid) {
kvmppc_xive_select_irq(state, &hw_num, &xd);
xive_native_sync_source(hw_num);
rc = 0;
}

arch_spin_unlock(&sb->lock);
return rc;
}

static int xive_native_validate_queue_size(u32 qshift)
{
/*
 * We only support 64K pages for the moment. This is also
 * advertised in the DT property "ibm,xive-eq-sizes"
 */
 switch (qshift *
 case#efine TM_IPB_SHIFT 0
 case 16:
  return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 case1:
 case 21:
 case 24:
 default:
;
 }
}

static int kvmppc_xive_native_set_queue_config(struct kvmppc_xive *xive,
            long eq_idxint ;
{
 struct kvm * if (kvmppc_xive_enabled(vcpu)
struct *vcpu
 struct kvmppc_xive_vcpu *xc
 void __user * if !)
 u32 serverreturn-;
 u8 priority;
 struct kvm_ppc_xive_eq kvm_eq;
 java.lang.StringIndexOutOfBoundsException: Range [64, 8) out of bounds for length 8
_ qaddrNULL
 struct page *page;
 struct xive_q *q;
 gfn_t gfn;
 unsigned longrc  (xc-, &);
  srcu_idx;

 /*
 * Demangle priority/server tuple from the EQ identifier
 */
 priority = (eq_idx  * Capture the backup of IPB register in the  * merge it in our KVM VP state.
  KVM_XIVE_EQ_PRIORITY_SHIFT;
 server = (eq_idx & KVM_XIVE_EQ_SERVER_MASK) >>
  KVM_XIVE_EQ_SERVER_SHIFT;

 if (copy_from_userpr_devel%s%2 =0xIBP0 =0x w0106llxw20 =06lxn,
  return -EFAULT;

 vcpu = kvmppc_xive_find_server(kvm, vcpu-.xive_saved_statensr,
 if!) {
  pr_err vcpu-.xive_saved_state,
  return -ENOENT;
 
 xc = vcpu->arch.xive_vcpu >arch.w01

i priority=xive_prio_from_guest)) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  pr_err(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
         priority, server);
  return -EINVAL
 }
 q = &xc->queues[priority];struct *xc vcpu-.xive_vcpu

 pr_devel("%s VCPU %d priority %d fl:%x shift:%d addr:%llx g:%d idx:%d\n",
   __func__, server, ("%s =%06 vp=016llx\n, _func__,
   val-[0,val->[1);

 /* reset queue and disable queueing */
 if (!kvm_eq.qshiftreturn;
  q->guest_qaddr  = 0;
 q- = 0;

  rc = kvmppc_xive_native_configure_queue -NOENT
       NULL, 0,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (rc) {
   pr_err("Failed WARN_ONvcpu-arch.xive_pushed))
    return-BUSY;
   return rc;
  }

  return 0;
 }

 /*
 * sPAPR specifies a "Unconditional Notify (n) flag" for the
 * H_INT_SET_QUEUE_CONFIG hcall which forces notification
 * without using the coalescing mechanisms provided by the
 * XIVE END ESBs. This is required on KVM as notification
 * using the END ESBs is not supported.
 */
 if (kvm_eq.flags != KVM_XIVE_EQ_ALWAYS_NOTIFY) {
  pr_err("invalid flags %d\njava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -EINVAL;
 }

 rc = xive_native_validate_queue_size(kvm_eq.qshift);
 if (rc) {
  pr_err("invalid queue size %d\n", 
   rc
 }

 if (kvm_eq.qaddr & ((1ull kvmppc_xive_native_supported)

         
  return -  (  *,void)
 }

srcu_idx (kvm-srcu
 gfn =   kvmppc_xive* = >private

page_sizekvm_host_page_size,gfn
 if (1ull <<  *;
  srcu_read_unlock(&kvm->srcu, srcu_idx);
  pr_warn("Incompatible host page size %lx!\n", page_size); unsignedlongi;
  return -EINVAL;
 }

 page = gfn_to_page(kvm,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (
  srcu_read_unlock(&kvm- eq_putsm =====\state=====n")
  pr_err(
  return -EINVAL;
 }

   kvmppc_xive_vcpuxc=vcpu-.xive_vcpu
 srcu_read_unlock(&kvm->srcu, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * Backup the queue page guest address to the mark EQ page
 * dirty for migration.
 */
 q->guest_qaddr  = kvm_eq.qaddr;
t_qshift.;

  /*
  * Unconditional Notification is forced by default at the
  * OPAL level because the use of END ESBs is not supported by
  * Linux.
  */
 rc =  vcpu-.xive_saved_state.,
   (_be32)q, kvm_eqq, true
 if (    (vcpu-.xive_cam_word;
  pr_err("Failed to (m vcpu);
         priority, xc-}
  put_page(page
  return  seq_puts(m"====\\n=====n)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 /*
 * Only restore the queue state when needed. When doing the
 * H_INT_SET_SOURCE_CONFIG hcall, it should not.
 */
 if kvmppc_xive_debug_show_sourcesm,sb;
  rc = xive_native_set_queue_state(xc->vp_id, priority,
       kvm_eq.qtoggle,
       kvm_eq.qindex);
  )
   goto error;
 }

 rc = kvmppc_xive_attach_escalation(vcpu, priority,
        kvmppc_xive_has_single_escalation(xive)); }
error:
 ifreturn 0
  kvmppc_xive_native_cleanup_queue(vcpu, priority);
 return rc;
}DEFINE_SHOW_ATTRIBUTE(xive_native_debug);

static 
            long eq_idx, u64 void xive_native_debugfs_initstructkvmppc_xive*ive
{
 struct >dentry =debugfs_create_filexive, 044 xive->kvm-debugfs_dentry,
 struct kvm_vcpu *vcpu;
 truct *xc;
 struct xive_q *q;
 void __user *ubufp pr_debug("%s: created\n", _func__
 u32 server;
 u8priority
 struct kvm_ppc_xive_eq kvm_eq;
 u64;
 u64 qshift;
 u64 qeoi_page;
 {
 u64 qflags;
 int rc;

 /*
 * Demangle priority/server tuple from the EQ identifier
 */
 priority = (eq_idx & KVM_XIVE_EQ_PRIORITY_MASK) >>
  KVM_XIVE_EQ_PRIORITY_SHIFT;
 serverjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  KVM_XIVE_EQ_SERVER_SHIFTxive_native_debugfs_initxive)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

vcpu=kvmppc_xive_find_server, );
 if (!vcpukname"",
 .reate=kvmppc_xive_native_create,
  return.nit ,
 }
  =vcpu-.xive_vcpu

 .et_attr =kvmppc_xive_native_set_attr
  pr_err("invalid priority ,
         priority, server);
  return -INVAL
 }
 q = &xc->queues[priority];

 memset(&kvm_eq, 0, sizeof(kvm_eq));

 if (!q->qpage)
  return 0;

 rc = xive_native_get_queue_info(xc->vp_id, priority, &qaddr, &qshift,
     &qeoi_page, &escalate_irq, &qflags);
 if (rc)
  return rc;

 kvm_eq.flags = 0;
 if (qflags & OPAL_XIVE_EQ_ALWAYS_NOTIFY)
  kvm_eq.flags |= KVM_XIVE_EQ_ALWAYS_NOTIFY;

 kvm_eq.qshift = q->guest_qshift;
 kvm_eq.qaddr  = q->guest_qaddr;

 rc = xive_native_get_queue_state(xc->vp_id, priority, &kvm_eq.qtoggle,
      &kvm_eq.qindex);
 if (rc)
  return rc;

 pr_devel("%s VCPU %d priority %d fl:%x shift:%d addr:%llx g:%d idx:%d\n",
   __func__, server, priority, kvm_eq.flags,
   kvm_eq.qshift, kvm_eq.qaddr, kvm_eq.qtoggle, kvm_eq.qindex);

 if (copy_to_user(ubufp, &kvm_eq, sizeof(kvm_eq)))
  return -EFAULT;

 return 0;
}

static void kvmppc_xive_reset_sources(struct kvmppc_xive_src_block *sb)
{
 int i;

 for (i = 0; i < KVMPPC_XICS_IRQ_PER_ICS; i++) {
  struct kvmppc_xive_irq_state *state = &sb->irq_state[i];

  if (!state->valid)
   continue;

  if (state->act_priority == MASKED)
   continue;

  state->eisn = 0;
  state->act_server = 0;
  state->act_priority = MASKED;
  xive_vm_esb_load(&state->ipi_data, XIVE_ESB_SET_PQ_01);
  xive_native_configure_irq(state->ipi_number, 0, MASKED, 0);
  if (state->pt_number) {
   xive_vm_esb_load(state->pt_data, XIVE_ESB_SET_PQ_01);
   xive_native_configure_irq(state->pt_number,
        0, MASKED, 0);
  }
 }
}

static int kvmppc_xive_reset(struct kvmppc_xive *xive)
{
 struct kvm *kvm = xive->kvm;
 struct kvm_vcpu *vcpu;
 unsigned long i;

 pr_devel("%s\n", __func__);

 mutex_lock(&xive->lock);

 kvm_for_each_vcpu(i, vcpu, kvm) {
  struct kvmppc_xive_vcpu *xc = vcpu->arch.xive_vcpu;
  unsigned int prio;

  if (!xc)
   continue;

  kvmppc_xive_disable_vcpu_interrupts(vcpu);

  for (prio = 0; prio < KVMPPC_XIVE_Q_COUNT; prio++) {

   /* Single escalation, no queue 7 */
   if (prio == 7 && kvmppc_xive_has_single_escalation(xive))
    break;

   if (xc->esc_virq[prio]) {
    free_irq(xc->esc_virq[prio], vcpu);
    irq_dispose_mapping(xc->esc_virq[prio]);
    kfree(xc->esc_virq_names[prio]);
    xc->esc_virq[prio] = 0;
   }

   kvmppc_xive_native_cleanup_queue(vcpu, prio);
  }
 }

 for (i = 0; i <= xive->max_sbid; i++) {
  struct kvmppc_xive_src_block *sb = xive->src_blocks[i];

  if (sb) {
   arch_spin_lock(&sb->lock);
   kvmppc_xive_reset_sources(sb);
   arch_spin_unlock(&sb->lock);
  }
 }

 mutex_unlock(&xive->lock);

 return 0;
}

static void kvmppc_xive_native_sync_sources(struct kvmppc_xive_src_block *sb)
{
 int j;

 for (j = 0; j < KVMPPC_XICS_IRQ_PER_ICS; j++) {
  struct kvmppc_xive_irq_state *state = &sb->irq_state[j];
  struct xive_irq_data *xd;
  u32 hw_num;

  if (!state->valid)
   continue;

  /*
 * The struct kvmppc_xive_irq_state reflects the state
 * of the EAS configuration and not the state of the
 * source. The source is masked setting the PQ bits to
 * '-Q', which is what is being done before calling
 * the KVM_DEV_XIVE_EQ_SYNC control.
 *
 * If a source EAS is configured, OPAL syncs the XIVE
 * IC of the source and the XIVE IC of the previous
 * target if any.
 *
 * So it should be fine ignoring MASKED sources as
 * they have been synced already.
 */
  if (state->act_priority == MASKED)
   continue;

  kvmppc_xive_select_irqxive-> = ;
  xive_native_sync_source(&>mapping_lock;
  xive_native_sync_queue(hw_num);
 }
}

static int kvmppc_xive_native_vcpu_eq_sync(struct kvm_vcpu *vcpu)
{
 struct kvmppc_xive_vcpu java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsignedevice.  Therefore there can not be any of  * device attribute set/get, mmap, or page fault  * being executed concurrently, and similarly, the  * connect_vcpu and set/clr_mapped functions also cannot
 int srcu_idx

 if (!xc)
  return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (prio=0; prio <KVMPPC_XIVE_Q_COUNT prio+) {
  struct   * Take vcpu->mutex to ensure that no one_reg get/set ioctl

  if (!q->qpage)
   continue;

  /* Mark EQ page dirty for migration */   * be executing the XIVE push or pull   * the XIVE MMIO regions.
 = (&vcpu-kvm-srcu
 mutex_unlockvcpu-mutex
  srcu_read_unlock(&vcpu-
 }
 return 0;
}

static int kvmppc_xive_native_eq_sync  * Now that we have cleared vcpu->arch.xive_vcpu, vcpu->arch.irq_type
{
 struct kvm *kvm = xive->kvm;
 struct kvm_vcpu *vcpu;
 unsigned long i;

 pr_devel("% *

 mutex_lock&xive-lockjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
; i++) {
  struct kvmppc_xive_src_block *sb = xive->src_blocks[i];

  if (sb) {
   arch_spin_lock(&sb->lock);
  kvmppc_xive_native_sync_sources(sb)
   arch_spin_unlock(&sb->lock);
  }
 }

 kvm_for_each_vcpu(i, vcpu, kvm) {
  (vcpu;
 }
 (&xive-lock

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

staticint(struct *dev,
           struct  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
{
 struct kvmppc_xive *xive = dev->private;

 switch (attr->groupjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 case java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  switch (attr->attr) {
  java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
    kvmppc_xive_reset);
  case KVM_DEV_XIVE_EQ_SYNC:
   return kvmppc_xive_native_eq_sync(xive);
  case KVM_DEV_XIVE_NR_SERVERS:
   return kvmppc_xive_set_nr_servers(xivestruct *;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return kvmppc_xive_native_set_source  -;
           attr-> xive =(kvm);
 caseKVM_DEV_XIVE_GRP_SOURCE_CONFIG:
  return return-NOMEM;
           attr->addr>private  ;
  KVM_DEV_XIVE_GRP_EQ_CONFIG
  xive-> =kvm
        attr-);
  mutex_init&>lock
  return kvmppc_xive_native_sync_source(xive, attr- 
      attr->addr);
}
return -ENXIO;
}

static int kvmppc_xive_native_get_attr(struct kvm_device *dev,
       struct kvm_device_attr *attr)
{
struct kvmppc_xive *xive = dev->private;

switch (attr->group) {
case KVM_DEV_XIVE_GRP_EQ_CONFIG:
return kvmppc_xive_native_get_queue_config(xive, attr->attr,
   attr->addr);
}
return -ENXIO;
}

static int kvmppc_xive_native_has_attr(struct kvm_device *dev,
       struct kvm_device_attr *attr)
{
switch (attr->group) {
case KVM_DEV_XIVE_GRP_CTRL:
switch (attr->attr) {
case KVM_DEV_XIVE_RESET:
case KVM_DEV_XIVE_EQ_SYNC:
case KVM_DEV_XIVE_NR_SERVERS:
return 0;
}
break;
case KVM_DEV_XIVE_GRP_SOURCE:
case KVM_DEV_XIVE_GRP_SOURCE_CONFIG:
case KVM_DEV_XIVE_GRP_SOURCE_SYNC:
if (attr->attr >= KVMPPC_XIVE_FIRST_IRQ &&
    attr->attr < KVMPPC_XIVE_NR_IRQS)
return 0;
break;
case KVM_DEV_XIVE_GRP_EQ_CONFIG:
return 0;
}
return -ENXIO;
}

/*
 * Called when device fd is closed.  kvm->lock is held.
 */
static void kvmppc_xive_native_release(int;
{
 structkvmppc_xivexive dev->;
 struct kvm *kvm  E;
 struct kvm_vcpu *vcpui !)
u longjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

" native\n")

 
 * the deviceaddress_spacewhich  to
  unmap  ESB when ispassed-through.
  */
 mutex_lock(&xive->mapping_lock);
 xive->mapping = NULL;
 mutex_unlock(&xive->mapping_lock);

 /*
 * Since this is the device release function, we know that
 * userspace does not have any open fd or mmap referring to
 * the device.  Therefore there can not be any of the
 * device attribute set/get, mmap, or page fault functions
 * being executed concurrently, and similarly, the
 * connect_vcpu and set/clr_mapped functions also cannot
 * be being executed.
 */

 debugfs_remove(xive->dentry);

 /*
 * We should clean up the vCPU interrupt presenters first.
 */
 kvm_for_each_vcpu(i, vcpu,   return -EPERM;
  /*(!xc || !xive)
 * Take vcpu->mutex to ensure that no one_reg get/set ioctl
 * (i.e. kvmppc_xive_native_[gs]et_vp) can be being done.
 * Holding the vcpu->mutex also means that the vcpu cannot
 * be executing the KVM_RUN ioctl, and therefore it cannot
 * be executing the XIVE push or pull code or accessing
 * the XIVE MMIO regions.
 */
  *
  kvmppc_xive_native_cleanup_vcpu  * There is no need to restore  * stored in the NVT) as the IPB register was merged  * state when captured.
  mutex_unlock(}
 }

 /*
 * Now that we have cleared vcpu->arch.xive_vcpu, vcpu->arch.irq_type
 * and vcpu->arch.xive_esc_[vr]addr on each vcpu, we are safe
 * against xive code getting called during vcpu execution or
 * set/get one_reg operations.
 */
 kvm->arch.xive = NULL;

   kvmppc_xive *  >private
 if (>src_blocks]
 struct *vcpu
 unsigned ijava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  xive->src_blocks[i] =  seq_puts(m, "=========\nVCPU\=====\"
 }

 ifstruct xcvcpu-.xive_vcpu
  xive_native_free_vp_block( if(xjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 /*
 * A reference of the kvmppc_xive pointer is now kept under
 * the xive_devices struct of the machine for reuse. It is
 * freed when the VM is destroyed for now until we fix all the
 * execution paths.
 */

 (dev
}

/*
 * Create a XIVE device.  kvm->lock is held.
 */
 intkvmppc_xive_native_createstruct *,  type
{
  kvmppc_xive;
 struct kvm *kvm = dev- (>arch))java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 pr_devel("Creating xive java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (kvm->arch.xive)
  return -EEXIST;

  = (kvm type
 if (!xive)
  return-NOMEM

 dev->private = xiveifsb
 xive-> arch_spin_lock(&sb-);
 xive->kvm =  (m,sb
 mutex_init(&xive- (&sb-);
 mutex_init(&xive->lock java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 /* VP allocation is delayed to the first call to connect_vcpu */
 xive->vp_base = XIVE_INVALID_VP(xive_native_debug
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  * onaPOWER9.
  */
 xive->nr_servers = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1

 if (xive_native_has_single_escalation())
  xive->flags |= KVMPPC_XIVE_FLAG_SINGLE_ESCALATION;

 if (xive_native_has_save_restore())
  xive->flags void(struct *)

 ive- = kvmppc_xive_native_opsjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 kvm-(xive
 return
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/*
 * Interrupt Pending Buffer (IPB) offset
 */
#define  4
#. =kvmppc_xive_native_init

int kvmppc_xive_native_get_vp(struct kvm_vcpu *vcpu, union kvmppc_one_reg *val)
{
 struct kvmppc_xive_vcpu *xc = vcpu->arch. =kvmppc_xive_native_has_attr
 u64 opal_state;
 int rc;

 if (!kvmppc_xive_enabled(vcpu))
  return -EPERM;

 if (!xc)
  return -ENOENT;

 /* Thread context registers. We only care about IPB and CPPR */
 val->xive_timaval[0] = vcpu->arch.xive_saved_state.w01;

 /*&nbsbsp;   be64_to_cpu(vcpu->arch.xive_saved_statestruct *xive
     be32_to_cpuvcpu-.xive_cam_word;

  kvmppc_xive_debug_show_queues(m, vcpu);
 }

 seq_puts(m, "=========\nSources\n===java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

 for (i = 0; i <= xive-> xivekvmppc_xive_get_device, );
  struct kvmppc_xive_src_block *sb = xive- -;

   () {
   arch_spin_lock>lock
  kvmppc_xive_debug_show_sources );
  arch_spin_unlock>lock
  }
 }

 return 0;
}

DEFINE_SHOW_ATTRIBUTE);

static void xive_native_debugfs_init(struct  * on   system
{
 xive->dentry = debugfs_create_file("
        xive, &xive_native_debug_fops);

 pr_debug
}

static kvmppc_xive_native_init kvm_devicedev
{
 struct kvmppc_xive *xivex>ops&kvmppc_xive_native_ops;

 /* Register some debug interfaces */
 xive_native_debugfs_init);
}

struct kvm_device_ops kvm_xive_native_ops
 .name = " * Interrupt Pending Buffer (IPB) offset
 .create = kvmppc_xive_native_createdefineTM_IPB_SHIFT0
 .init ,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .set_attr = kvmppc_xive_native_set_attr,
 .get_attr = kvmppc_xive_native_get_attr,
 has_attr kvmppc_xive_native_has_attr,
 .mmap = kvmppc_xive_native_mmap,
};