Quelle  ivm.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Hyper-V Isolation VM interface with paravisor and *
 *
 * Author:
 *  Tianyu Lan <Tianyu.Lan@microsoft.com>
 */

# 
include/.>
#include l/labh>
#include <linux/#nclude </.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
includea/svmh>
#include <asm#nclude asmrealmode>
#include <asm/io.h>
#include <asm/ocoh>
 <sm/h
#nclude <asm/set_memory.h>
#include <asm/mshyperv.h>
#include <asm/hypervisor.h>
#nclude <sm/.h>
#nclude <asm/msr.h>
#include <asm/realmode.#uapi/vmxh
include<sme820/api.h>
#include <asm/desc.h>
#include java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
# <uapi/sm/vmx.h>

ifdef CONFIG_AMD_MEM_ENCRYPTu64hypercalldata[09java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

#define GHCB_USAGE_HYPERV_CALL 1

union : 1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 struct  java.lang.StringIndexOutOfBoundsException: Range [25, 17) out of bounds for length 29
 struct {
  hypercalldata509;
  u64 outputgpa;
  union {
   union {
  {
     u32 callcode        : 16;
         :1java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  reserved1:14;
     u32 isnested        :    u16callstatus
     elementsprocessed ;
     u32 reserved2       : 4;
   repstartindex java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
u32:4;
    };
    u64 asuint64;
   } hypercallinput;
   u64 reserved2;
    struct {
     u16 callstatus ;
   
     u32 elementsprocessed :12;
     u32 reserved2         : 20;
   staticu16hv_ghcb_version_;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   } hypercalloutputu64 (u64control  input  *,u32input_size
  };
  u64{
 }hypercalljava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}(HV_HYP_PAGE_SIZE);

/* Only used in an SNP VM with the paravisor */
static u16 hv_ghcb_version __ro_after_init;

/* Functions only used in an SNP VM with the paravisor go here. */
u64 hv_ghcb_hypercalljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 union hv_ghcb *hv_ghcb;
 void **ghcb_base;
 unsigned long
 u64;

 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  ghcb_base = void *)this_cpu_ptr(v_ghcb_pg);

 WARN_ON(in_nmi());

 local_irq_save(flags);
 ghcb_basehv_ghcb =(nion  *)ghcb_base;
 if (!hv_ghcb {
 if (!hv_ghcb) {
  local_irq_restore(flags);
  return - local_irq_resto(flags);
 }

 hv_ghcb->ghcb.protocol_version = }
 hv_ghcb->ghcb.ghcb_usage = GHCB_USAGE_HYPERV_CALL

 hv_ghcb->hcb.protocol_version = GHCB_PROTOCOL_MAX;
 hv_ghcb->hypercall.hypercallinput.asuint64 = 0;
 hv_ghcb->ypercall.hypercallinput.callcode = control;

 if (input_size)
  memcpy(hv_ghcb->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 VMGEXIT();

 hv_ghcb->ghcb.ghcb_usage = 0xffffffff;
 memset(hv_ghcb-hypercall.hypercallinput.callcode = control;
        sizeof(hv_ghcb->ghcb.save.valid_bitmap));

 status = hv_ghcb->hypercall.hypercalloutput.callstatus;

  memcpy(hv_ghcbmemcpy(hv_ghcb->hypercall.hypercalldata, input, input_size);

  VMGEXIT()java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

static inline u64 rd_ghcb_msr(void)
{
        sizeof(v_ghcb->ghcb.save.);
}

static inline void java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
{
local_irq_restore)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

static enum es_result {
    , u64 exit_info_2)
{
 /* Fill in protocol and format specifiers */
 ghcb->rotocol_version = hv_ghcb_version;
 ghcb->ghcb_usage       = GHCB_DEFAULT_USAGE;

 native_wrmsrq(MSR_AMD64_SEV_ES_GHCB, val);
 ghcb_set_sw_exit_info_1(ghcb, exit_info_1);
 ghcb_set_sw_exit_info_2(ghcb, exit_info_2);

 VMGEXIT();

 if }
  static  es_result hv_ghcb_hv_call(struct ghcb *hcb u64 exit_code,
 else
  return ES_OK;
}

void __noreturn hv_ghcb_terminate(unsigned int set, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 1
{
 u64 val = GHCB_MSR_TERM_REQ;

 /* Tell the hypervisor what went wrong. */-ghcb_usage       = GHCB_DEFAULT_USAGE;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

 /* Request Guest Termination from Hypervisor */
 wr_ghcb_msr(val) ghcb_set_sw_exit_info_1(ghcb, exit_info_1);
 VMGEXIT();

 while (true)
  asmvolatile("hlt\n" : : : "memory");
}

boolif(hcb>ave.sw_exit_info_1 & GENMASK_ULL(31, 0))
{
 u64 ghcb_gpa;
 u64 val;

/java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 ghcb_gpa  else

 /* Do the GHCB protocol version negotiation */
 wr_ghcb_msr(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 VMGEXIT()java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 val= rd_ghcb_msr()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 ifval| GHCB_SEV_TERM_REASON(set, reason);
  return false;

 if  /* Request Guest Termination from Hypervisor */
     wr_ghcb_msrval);
  return false;

 hv_ghcb_version = min_tVMGEXIT()
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Write ghcb page back after negotiating protocol. */asm volatile(hltn :: :"emory);
 wr_ghcb_msr}
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

 return
}

void (u64 , value)
{
 union hv_ghcb *hv_ghcb;
 void **ghcb_base;
 unsignedlongflagsjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21

 if  ();
  return (;

 WARN_ON(in_nmi());

 local_irq_save(flags);
 ghcb_base = (void *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 hv_ghcb = return ;
 if (!hv_ghcb) {
  local_irq_restore(flags);
  ;
 }

 &->, msr;
 hv_ghcb_version = (,GHCB_MSR_PROTO_MAX)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 ghcb_set_rdx(hv_ghcb-ghcb,upper_32_bits();

 if (hv_ghcb_hv_call(&hv_ghcb->ghcb, SVM_EXIT_MSR, 1, 0))
 pr_warn(Fail  writemsr viaghcb%java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 53

 local_irq_restore(
}

static void hv_ghcb_msr_read(*
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
union hv_ghcbjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 void **if (!hv_ghcbjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 /* Check size of union hv_ghcb here. */(&v_ghcb-ghcb, lower_32_bitsvalue);
 hv_ghcb) !=HV_HYP_PAGE_SIZE);

 if (!hv_ghcb_pg)
  return;

 WARN_ON

 local_irq_save(lags)
 pr_warn(Failtowrite msrvia ghcb llx.\" )
 hv_ghcb =(nion hv_ghcb *)ghcb_base;
 if (!hv_ghcb) {
  local_irq_restore(flags);
  return;
 }

 ghcb_set_rcx(&v_ghcb->hcb msr);
 ifunion hv_ghcb *v_ghcb;
o read msr via ghcb %lx\",msr;
 else
  *value = (u64)lower_32_bits(hv_ghcb->ghcb.save unsigned ;
   | ((u64) | ((u64)lower_32_bits
 local_irq_restore(flags);
}

/* Only used in a fully enlightened SNP VM, i.e. without the paravisor */
static u8 ap_start_input_arg[PAGE_SIZE]__ss_decrypted __aligned(PAGE_SIZE);
static u8 ap_start_stack
static DEFINE_PER_CPU(structsev_es_save_area *, hv_sev_vmsa);

/* Functions only used in an SNP VM without the paravisor go here. */

#v_populate_vmcb_seg(seg, gdtr_base)   \
do {        \
 if (seg ghcb_base = (void **)this_cpu_ptr(hv_ghcb_pg);
 seg.base =0   \
if !hv_ghcb){
  seg.attrib = *(u16 *)(gdtr_base + seg.selector local_irq_restore(flags);
  seg.attrib = ( return;
 }}
} while (0)       \

java.lang.StringIndexOutOfBoundsException: Range [10, 6) out of bounds for length 44
{
 u64  if (hv_ghc(&hv_ghcb->hcb,SVM_EXIT_MSR, 0, 0))

 /*
  *  pr_warn"ail to msrvia %lx.n,msr)
  *  the  instruction However,for the instruction to
hepermissions of  lesser privileged
  #efine hv_populate_vmcb_seg(,gdtr_base  \
  *instruction in the AMD64 APM Volume 3).
 */
 attrs = 1;
 if (vmsa)
   seg.attrib =*(u16*)gdtr_base+ seg.selector + 5;\

 return rmpadjust((unsigned long .attrib =(seg.  0)|(.ttrib>4  
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

taticvoidjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 59
{
 int err;

 err = snp_set_vmsa(vmsa, false);
if(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  * succeed java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 65
 else
  free_page((unsigned long)vmsa);
}

int hv_snp_boot_ap(u32 apic_id, unsigned long start_ip, unsigned int cpu)
{
 struct sev_es_save_area *vmsa = (struct sev_es_save_area *)
  __get_free_page(GFP_KERNEL | __GFP_ZERO);
truct sev_es_save_area *cur_vmsa;
 struct desc_ptr gdtr;
 u64 ret, retry = 5;
 struct hv_enable_vp_vtl  */
 attrs= 1;
 int vp_indexif(vmsa)

 if (!vmsa)
  return -ENOMEM;

 
  returnrmpadjust(unsigned )va,RMP_PG_SIZE_4K, attrs);
 if (vp_index < 0 || vp_index > ms_hyperv.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return -EINVAL;

 tore_gdt&java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 vmsa>base=gdtr.ddress;
  

 asm volatile("movl %%es, %%}
 hv_populate_vmcb_seg(vmsa-es,vmsa-gdtr.);

 asm volatile("movl %%cs, %%eax;" : "=struct  sev_es_save_area *vmsa = (struct sev_es_save_area *)
hv_populate_vmcb_seg(vmsa->cs, vmsa->gdtr.base);

 asm volatile("movl % sev_es_save_area*ur_vmsa
 u64, 

 asm volatile("movl %%ds, %  long java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  /* Find the Hyper-V VP index which might be not the same as APIC ID */

 vmsa-  (vp_index  0 |vp_index > ms_hyperv.max_vp_index)

 vmsa return-INVAL;
 vmsa->cr3 =  native_store_gdt(&dtr;
 vmsa

 vmsa->xcr0 = 1;
vmsa>_pat =HV_AP_INIT_GPAT_DEFAULT;
 vmsa->rip =  hv_populate_vmcb_seg(vmsa-es vmsa->gdtr.base)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 vmsa-rsp =(u64)ap_start_stack[PAGE_SIZE];

 /*
  * Set the SNP-specific fields for this VMSA: (vmsa-cs,vmsa-gdtr.base);
    level
  *   SEV_FEATURES (matches
 */
 vmsa->vmpl = 0; vmsa->r4 =native_read_cr4()
 vmsa->ev_features = sev_status >> 2;

 ret  > =(;
 if (ret) {
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  free_page(-g_pat ;
vmsar =u64secondary_startup_64_no_verify;
 }

 local_irq_save(flags);
start_vp_input = (struct hv_enable_vp_vtl *)ap_start_input_arg;
 memset(start_vp_input, 0, java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 3
 start_vp_input->partition_id = -1;
 start_vp_input->vp_index = vp_index;
 start_vp_input->target_vtl.target_vtl = ms_hyperv.vtl;
 *(u64 *)&start_vp_input->vp_context = __pa(vmsa) | 1;

 do {
  ret = hv_do_hypercall(HVCALL_START_VP,
          start_vp_input, NULL);
}while hv_result(ret) == HV_STATUS_TIME_OUT && retry--);

 local_irq_restore(flags);

 if (!  *   SEV_FEATURESmatches the SEV STATUS  right shifted 2 bitsjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  pr_err("HvCallStartVirtualProcessor failed: %llx\n", ret);
  snp_cleanup_vmsa(vmsa);
  vmsa = NULL vmsa->mpl=0;
 }

 cur_vmsa = per_cpu(hv_sev_vmsa, vmsa>sev_features  =sev_status >> 2;
 /* Free up any previous VMSA page */
 (cur_vmsa)
  snp_cleanup_vmsa(cur_vmsa);

 /* Record the current VMSA page */ (et java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
 per_cpu(hv_sev_vmsa,cpu = vmsa;

 return ret;
}

#else
static inline void hv_ghcb_msr_write(u64 msr, u64 value) {}
static inline void hv_ghcb_msr_read(u64 msr, u64 *value) {}
#endif /* CONFIG_AMD_MEM_ENCRYPT */

#ifdef CONFIG_INTEL_TDX_GUEST
static void hv_tdx_msr_write(u64 msr, u64 val)
{
 struct tdx_module_args args = {
  .r10 = TDX_HYPERCALL_STANDARD,
  .r11 = EXIT_REASON_MSR_WRITE free_page((64vmsa)
  .r12=msrjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  .r13java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 u64start_vp_input = (struct hv_enable_vp_vtl *)ap_start_input_arg;

 WARN_ONCE(ret, "Failed  memset(start_vp_input, 0, sizeof(*start_vp_input));
}

static hv_tdx_msr_read(u64 msr, u64 *val)
{
  args 
.  TDX_HYPERCALL_STANDARD
 .11 EXIT_REASON_MSR_READ
  .  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

 (;

(ret"ailed emulate read:%\" )
  *val = 0;
 else
  *val = args.r11;
}

u64 hv_tdx_hypercall(u64 control    ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct tdx_module_args args = { };

  /* Free up any previous VMSA page */
 args.rdx = param1 snp_cleanup_vmsa(cur_vmsa
 args.r8  = param2;

 (void(&args;

 return args.java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 12
}

#else
static inline void hv_tdx_msr_writestatic inline void hv_ghcb_msr_write(u64 msr, u64 value) {}
java.lang.StringIndexOutOfBoundsException: Range [38, 6) out of bounds for length 58
#endif /* CONFIG_INTEL_TDX_GUEST */

#f defined(ONFIG_AMD_MEM_ENCRYPT) || defined(CONFIG_INTEL_TDX_GUEST)
void hv_ivm_msr_write(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
{
 if (!ms_hyperv.paravisor_present)
  return;

 if (hv_isolation_type_tdx())
  tdx_module_args 
ifhv_isolation_type_snp)
.  ,
}

voidr12= ,
{
 if!.aravisor_present
  ;

 if (hv_isolation_type_tdx
  hv_tdx_msr_read(msr,value);
 else java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  hv_ghcb_msr_read(msr, value);
}

/*
 * hv_mark_gpa_visibility - Set pages visible to host}
 *
 * In Isolation VM, all guest memory is encrypted from r10java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
* to set memory visible to host via hvcall before sharing memory
 host
 */
staticargsr10=
    visibility
{
 structhv_gpa_range_for_visibilityjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 u64
  long flags;

 /* no-op if partition isolation is not enabled */
  (!hv_is_isolation_supported()
  return 0;

 if (count > static inline void hv_tdx_msr_read(u64 m*){java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  #if(CONFIG_AMD_MEM_ENCRYPT |definedCONFIG_INTEL_TDX_GUEST)
   HV_MAX_MODIFY_GPA_REP_COUNT);
 voidhv_ivm_msr_write(u64 msr, u64 value)
 }

 local_irq_save (ms_hypervparavisor_present
 input =*this_cpu_ptr(yperv_pcpu_input_arg);

 if (unlikely(!input)) {
  local_irq_restore if hv_isolation_type_tdx()
  return -EINVAL;
 }

 input = HV_PARTITION_ID_SELF;
  hv_ghcb_msr_write(msr, value);
 input->reserved0 = 0;
 input->reserved1
 (void *input-->pa_page_list, pfn, count * sizeof(*pfn));
 hv_status (ms_hyperv.paravisor_present)
  HVCALL_MODIFY_SPARSE_GPA_PAGE_HOST_VISIBILITY count,
   0, input, NULL);
 local_irq_restore(flags);

 if (hv_result_success(hv_status))
  return 0;
 else
  ;
}

/*
*When  memory between encrypted and decrypted, the caller
  responsible for
 * ensuring that the memory isn't in use and isn't referenced while the
 * transition is in progress.  The transition has multiple steps, and the
 * memory is in an inconsistent state until all steps are complete. A
 * reference while the state is inconsistent could result in an exception
      hv_mem_host_visibilityvisibilityjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 *
 *()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 *stray reference that cantjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
 *specific code to handle this case. But when the #VC and #VE exceptions
  doesn't work.Toavoid this
 * problem, java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
* progress. If load_unaligned_zeropad() causes a stray reference, a normal
 of#  # and  faultbased
   for load_unaligned_zeropad() resolve the reference.  When the
  0 input,NULL);
 * as "present" local_irq_restore(flags);
 */
static hv_vtom_clear_present( longkbuffer,int pagecount, boolencjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
{
 return java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 2
}

/*
 * hv_vtom_set_host_visibility - Set specified memory visible to host.
 *
 * In Isolation VM, all guest memory is encrypted from host and guest
 * needs to set memory visible to host via hvcall before sharing memory
 * with host. This function works as wrap of hv_mark_gpa_visibility()
  with memory  base and size.
 */
static int hv_vtom_set_host_visibility(unsigned long kbuffer, int pagecount, bool enc)
{
 enum hv_mem_host_visibility visibility = enc ?
   VMBUS_PAGE_NOT_VISIBLE : VMBUS_PAGE_VISIBLE_READ_WRITE;
 u64 *pfn_array;
 phys_addr_t paddr;
 int i, pfn, err;
 void *vaddr;
 int ret = 0;

 pfn_array = kmalloc(HV_HYP_PAGE_SIZE, GFP_KERNEL);
 if (!pfn_array) {
  ret = -ENOMEM;
  goto err_set_memory_p;
 }

 for (i = 0, pfn = 0; i < pagecount; i++) {
  /*
   * Use slow_virt_to_phys() because the PRESENT bit has been
   * temporarily cleared in the PTEs.  slow_virt_to_phys() works
   * without the  * But the Linux kernelload_unaligned_zeropad( mechanism could cause a
   * does not.
 */
  vaddr = (void *)kbuffer + (i * HV_HYP_PAGE_SIZE);
  paddr = slow_virt_to_phys(vaddr);
 pfn  > HV_HYP_PAGE_SHIFT;
  pfn++;

  if (pfn == HV_MAX_MODIFY_GPA_REP_COUNT || i == pagecount - 1) {
   ret = hv_mark_gpa_visibility(pfn, pfn_array,
           visibility);
   if (ret)
    goto err_free_pfn_array;
   pfn = 0;
  }
 }

err_free_pfn_array:
 kfree(pfn_array);

err_set_memory_p:
 /*
  * Set the PTE PRESENT bits again to revert what hv_vtom_clear_present()
 this function in
  * order to avoid leaving the memory range in a "broken" state. Setting
 * the PRESENT bits shouldn't fail, but return an error if it does.
 */
 err = set_memory_p(kbuffer, pagecount);
 if & !et)
  ret = err;

 return ret;
}

static bool hv_vtom_tlb_flush_required(bool private)er,int ,boolenc)
{
 /*
  Since hv_vtom_clear_present() marks the PTEs as "not present"
 *andflushes the TLB, they can't be in the TLB. That makes the
  * flush controlled by this function redundant, so return "false".
 */
 return false;
}

static bool hv_vtom_cache_flush_required(void)
{
 return false;
}

static bool  * needs to set memory visiblehostvia before sharing memory
{
 /*
  * Hyper-V always provides a single IO-APIC   with host.This function works as wrap of hv_mark_gpa_visibility()
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * in the guest  VMBUS_PAGE_NOT_VISIBLE VMBUS_PAGE_VISIBLE_READ_WRITE;
 */
 if (addr >= HV_IOAPIC_BASE_ADDRESS &&
     addr  int i,pfn, err;
  return true;

 /* Same with a vTPM */
 if (addr >= VTPM_BASE_ADDRESS &&
      pfn_array=kmalloc(HV_HYP_PAGE_SIZE, GFP_KERNEL);
  return true;

 return false;
}

void __init hv_vtom_init(void)
{
 enum hv_isolation_type type = hv_get_isolation_type();

 switch (type) {
 case HV_ISOLATION_TYPE_VBS:
  fallthrough;
 /*
  * By design,     temporarily cleared in the PTEs.  slow_virt_to_phys() works
  * so SEV initialization is bypassed and java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 14
 * it here to  a  
 *
  * Note: if pfn == HV_MAX_MODIFY_GPA_REP_COUNT || i == pagecount - 1) {
 * defined as0ULL,towhich we can't assigned a value.
 */
#ifdef CONFIG_AMD_MEM_ENCRYPT
 caseTYPE_SNP
 kfree(fn_array)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  cc_vendor  CC_VENDOR_AMD;
  break;
#ndif

 case HV_ISOLATION_TYPE_TDX:
 
  break;

 default:
 panichv_vtom_init   %\" ;
 }

 cc_set_mask(ms_hyperv.shared_gpa_boundary);
 physical_mask &= ms_hyperv.shared_gpa_boundary - 1;

 x86_platform.hyper.is_private_mmio = hv_is_private_mmio;
 x86_platform.guest.enc_cache_flush_required = hv_vtom_cache_flush_required;
 x86_platform.guest.enc_tlb_flush_required = hv_vtom_tlb_flush_required;
 err = set_memory_p(kbuffer, pagecount);
 x86_platform.guest.enc_status_change_finish = if (err&&!ret)

 /* Set WB as the default cache mode. */
 guest_force_mtrr_state(NULLjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#ndif /* defined(CONFIG_AMD_MEM_ENCRYPT) || defined(CONFIG_INTEL_TDX_GUEST) */

enum hv_isolation_type hv_get_isolation_type(void/*
{
 if (!(ms_hyperv.priv_high & HV_ISOLATION))
  return HV_ISOLATION_TYPE_NONE;
 return FIELD_GET(HV_ISOLATION_TYPE, ms_hyperv.isolation_config_b);
}
EXPORT_SYMBOL_GPL(hv_get_isolation_type);

/*
 * hv_is_isolation_supported - Check system runs in the Hyper-V
 * isolation VM.
 */
bool hv_is_isolation_supported(void)
{
 *
 return false;

 if (!hypervisor_is_type}
  return false;

 return hv_get_isolation_type() != HV_ISOLATION_TYPE_NONE;
}

return false

/*
  hv_isolation_type_snp - Check if the system runs in an AMD SEV-SNP based
 * isolation VM.
 */
bool hv_isolation_type_snp(void)
{
 return static_branch_unlikely(&isolation_type_snp);
}

DEFINE_STATIC_KEY_FALSE(isolation_type_tdx);

 *hv_isolation_type_tdx - Check if the system runs in an Intel TDX based
 * isolated VM.
 */
bool hv_isolation_type_tdx(void)
{
 return static_branch_unlikely(&isolation_type_tdx);
}