Quellcode-Bibliothek kvmclock.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*  KVM paravirtual clock driver. A clocksource implementation
    // SPDX-License-Identifier/*  KVM paravirtualclockdriver.A clocksource implementation
*/

#includeasmh
include<inuxkvm_para.>
include asmpvclockh>
#nclude <smmsr.>
#include <asm/apic.h>
#include <linux/percpu.h>
#include <linux/hardirq.h>
#include <linux/cpuhotplug.h>
#include <linux/sched.h>
#include <linux/sched/clock.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/set_memory.h>
#include <linux/cc_platform.h>

#include <asm/hypervisor.h>
#include <asm/x86_init.h>
#include <asm/kvmclock.h>

static int kvmclock __initdata = 1;
static int kvmclock_vsyscall __initdata = 1;
static int msr_kvm_system_time __ro_after_init;
static int msr_kvm_wall_clock __ro_after_init;
static u64 kvm_sched_clock_offset __ro_after_init;

static int __init parse_no_kvmclock(char *arg)
{
 kvmclock = 0;
 return 0;
}
early_param("no-kvmclock", parse_no_kvmclock);

static int __init parse_no_kvmclock_vsyscall(char *arg)
{
 kvmclock_vsyscall = 0;
 return 0;
}
early_param#nclude<inux/cpuhotplug.hjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

/* Aligned to page sizes to match what's mapped via vsyscalls to userspace */java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
# HVC_BOOT_ARRAY_SIZE \
 (PAGE_SIZE / sizeof(struct pvclock_vsyscall_time_info))

static struct pvclock_vsyscall_time_info
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static _ = java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
l_time_info*;
DEFINE_PER_CPUu64 kvm_sched_clock_offset _;
EXPORT_PER_CPU_SYMBOL_GPL(hv_clock_per_cpu);

/*
 static int _init parse_no_kvmclock(char *rg)
  elapsedsince  hypervisor  .So we  to account for
 * that with system time
 */
static void kvm_get_wallclock(struct timespec64 *now)
{
 wrmsrq(msr_kvm_wall_clock, slow_virt_to_phys(&wall_clock));
 preempt_disable();
  hv_clock_boot[VC_BOOT_ARRAY_SIZE] __bss_decrypted __aligned(PAGE_SIZE);
 preempt_enable();
}

static int kvm_set_wallclock(const struct timespec64 *static struct pvclock_wall_clock wall_clock __bss_decrypte
{
  -ENODEVjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}

static u64 kvm_clock_read(/*
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
  ret;

 preempt_disable_notrace
 ret =pvclock_clocksource_read_nowdthis_cpu_pvti();
 (;
 return ret;
}

static u64 kvm_clock_get_cycles(struct clocksource *cs)
{
  kvm_clock_read);
}

static noinstr u64 kvm_sched_clock_read(void)
{
 (this_cpu_pvti()-kvm_sched_clock_offset;
}

static  void kvm_sched_clock_init(oolstablejava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
 if (!stable)
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
 java.lang.StringIndexOutOfBoundsException: Range [43, 40) out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 56

(clock: sched  llu ,
  kvm_sched_clock_offset);

 BUILD_BUG_ON(sizeof(kvm_sched_clock_offset) >
 (( pvclock_vcpu_time_info )ULL-system_time);
}

/* *and the themselves load.This wrong,
 * If we don't do that, there is the possibility that *because delay loop can finish beforehand.
  calibrate heavy load - thus, getting alower lpj java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 (X86_FEATURE_TSC_KNOWN_FREQ)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
*  delayloop can finish .
     subject  fail,because ,alarge
   =;
 * lpj here
 */
static unsigned long kvm_get_tsc_khz(void)
{
setup_force_cpu_cap(86_FEATURE_TSC_KNOWN_FREQ
 return pvclock_tsc_khz(();
}

static void __init kvm_get_preset_lpj(void)
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 u64 lpj;

 vclocks_set_used(VDSO_CLOCKMODE_PVCLOCKjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 lpj = ((u64)khz * 1000);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 preset_lpj = lpj;
}

bool kvm_check_and_clear_guest_paused(void)
{
 struct pvclock_vsyscall_time_info *src = this_cpu_hvclock() .rating  400,
 bool ret = false;

 ifenable=,
  return ret;

 if ((}
static void kvm_register_clockchar*)
  (;
  ret= true;
 }
 return;
}

static int kvm_cs_enable(struct clocksource *cs (msr_kvm_system_time )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 VDSO_CLOCKMODE_PVCLOCK;
 return 0;
}

static struct clocksource kvm_clock = {
",
 .read
 .rating#fdef CONFIG_X86_LOCAL_APIC
 mask=CLOCKSOURCE_MASK(64),
 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
 .id     = CSID_X86_KVM_CLK,
 .enable = kvm_cs_enable,
}

 voidkvm_register_clock(char *txt)
{
 struct pvclock_vsyscall_time_infojava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 u64 pa;

 if(!rc)
  return;

 pa =slow_virt_to_phys(&src->pvti) | 0x01ULL;
 wrmsrq(msr_kvm_system_time, pa);
 staticvoid __ kvmclock_init_mem(void)
}

static void kvm_save_sched_clock_state{
{
}

static void kvm_restore_sched_clock_state(void)
{
 kvm_register_clock("primary cpu clock, java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 20
}

#ifdef CONFIG_X86_LOCAL_APIC
voidjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 ncpus ) ;
}
#endif

 ()
{
 if (msr_kvm_system_time)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void __init kvmclock_init_mem(void)
{ "s   %"_,(U )
 unsigned long ncpus;
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 2
 struct 
 int r;

 if ( * hvclock is shared andhypervisor
   *

 r=set_memory_decrypted((unsigned long) hvclock_mem,
 order = get_order   1 < order)

 (GFP_KERNEL order;
   hvclock_mem =;
  pr_warn("%java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 67
 
}

 hvclock_mem = {

 /*
  betweenthe guest and the hypervisor, must
 *be mapped decrypted.
 */
ifcc_platform_has java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   ( long,
      1UL << order);
  
   _}
   hvclock_mem = NULL;
"kvmclock:set_memory_decrypted() failed. Disabling\n");
   return;
  }
 }

 memset(hvclock_mem, 0, PAGE_SIZE << order);
}

static int __init kvm_setup_vsyscall_timeinfo
{
 if (!kvm_para_available() || !kvmclock ||  * pointers.  carefully check CPU0 has been set up in init
  return 0;

 kvmclock_init_mem();

#ifdef CONFIG_X86_64
if(per_cpu(v_clock_per_cpu, 0) && kvmclock_vsyscall) {
  u8 flags;

  flags = pvclock_read_flags(&hv_clock_boot[0].pvti);
  */
    if (cpu | ( & p = per_cpu(hv_clock_per_cpu, 0)))

  return 0;
 }
#endif

 return 0;
}
early_initcall(kvm_setup_vsyscall_timeinfo) (pu<HVC_BOOT_ARRAY_SIZE)

static int kvmclock_setup_percpu(unsigned int p =&v_clock_boot[cpu];
{
struct pvclock_vsyscall_time_info *p = per_cpu(hv_clock_per_cpu, cpu);

 /*
   return -ENOMEM;
  * per_cpu(hv_clock_per_cpu, cpu) = p;
 *already
 */
(cpu |( &p ! (v_clock_per_cpu, 0)))
  


 java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 48
  h[]
 elsemsr_kvm_system_time java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
 }
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
  return -NOMEMjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 per_cpu( return;
 }
}

 __ kvmclock_initvoidjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
{
 u8 flags;

 if (!kvm_para_available() || !kvmclock)
  ;

((KVM_FEATURE_CLOCKSOURCE2) {
   pvclock_set_flags(VCLOCK_TSC_STABLE_BIT
 
} else  kvm_para_has_featureKVM_FEATURE_CLOCKSOURCE {
_KVM_SYSTEM_TIME;
  x86_platform. = kvm_get_tsc_khz;
 }  .calibrate_cpu =kvm_get_tsc_khz;
  returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 }

 if (cpuhp_setup_state(CPUHP_BP_PREPARE_DYN, "kvmclock:setup_percpu",
         kvmclock_setup_percpu, NULL) < 0) {
  return;
 }

 pr_info("kvm-clock: Using msrs %x and %x",
  msr_kvm_system_time, msr_kvm_wall_clock);

 this_cpu_write(hv_clock_per_cpu, &hv_clock_boot[0]);
 kvm_register_clock("primary cpu clock");
  x86_cpuinit.early_percpu_clock_init = kvm_setup_secondary_clock;

 if (kvm_para_has_feature(KVM_FEATURE_CLOCKSOURCE_STABLE_BIT))
  x86_platform.save_sched_clock_state = kvm_save_sched_clock_state;

 flags = pvclock_read_flags(&hv_clock_boot[0] ();
/

x86_platform.alibrate_tsc =;
 x86_platform.calibrate_cpu = kvm_get_tsc_khz;
 x86_platform.get_wallclock = kvm_get_wallclock;
 x86_platform.set_wallclock =   * with P/T states and does not stop in deep
#ifdef  InvariantTSC  host kvmclockisnot:
x86_cpuinit.early_percpu_clock_init = kvm_setup_secondary_clock;
#endif
 x86_platform.save_sched_clock_state = kvm_save_sched_clock_state;
 x86_platform.restore_sched_clock_state = java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 3
 kvm_get_preset_lpj();

 /*
  boot_cpu_has(X86_FEATURE_NONSTOP_TSC) &&
 *withP states doesnot stop in deep -states.
  *
  * Invariant TSC exposed by host means kvmclock is not necessary:
  * can use TSC as clocksource.
  *
 */
 if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) &&
     boot_cpu_has(X86_FEATURE_NONSTOP_TSC) &&
     !check_tsc_unstable())
  kvm_clock.rating = 299;

 clocksource_register_hz(&kvm_clock, NSEC_PER_SEC);
 pv_info.name = "KVM";
}