KVM
Classes | Macros | Functions | Variables
xen.h File Reference
#include <asm/xen/hypervisor.h>
#include <asm/pvclock-abi.h>
#include <asm/xen/interface.h>
#include <xen/interface/vcpu.h>
Include dependency graph for xen.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  compat_arch_vcpu_info
 
struct  compat_vcpu_info
 
struct  compat_arch_shared_info
 
struct  compat_shared_info
 
struct  compat_vcpu_runstate_info
 
struct  compat_sched_poll
 

Macros

#define COMPAT_EVTCHN_2L_NR_CHANNELS
 

Functions

static int kvm_xen_write_hypercall_page (struct kvm_vcpu *vcpu, u64 data)
 
static void kvm_xen_init_vm (struct kvm *kvm)
 
static void kvm_xen_destroy_vm (struct kvm *kvm)
 
static void kvm_xen_init_vcpu (struct kvm_vcpu *vcpu)
 
static void kvm_xen_destroy_vcpu (struct kvm_vcpu *vcpu)
 
static void kvm_xen_sw_enable_lapic (struct kvm_vcpu *vcpu)
 
static bool kvm_xen_msr_enabled (struct kvm *kvm)
 
static bool kvm_xen_hypercall_enabled (struct kvm *kvm)
 
static int kvm_xen_has_interrupt (struct kvm_vcpu *vcpu)
 
static void kvm_xen_inject_pending_events (struct kvm_vcpu *vcpu)
 
static bool kvm_xen_has_pending_events (struct kvm_vcpu *vcpu)
 
static int kvm_xen_has_pending_timer (struct kvm_vcpu *vcpu)
 
static void kvm_xen_inject_timer_irqs (struct kvm_vcpu *vcpu)
 
static bool kvm_xen_timer_enabled (struct kvm_vcpu *vcpu)
 
static void kvm_xen_update_tsc_info (struct kvm_vcpu *vcpu)
 
int kvm_xen_hypercall (struct kvm_vcpu *vcpu)
 
void kvm_xen_update_runstate (struct kvm_vcpu *vcpu, int state)
 
static void kvm_xen_runstate_set_running (struct kvm_vcpu *vcpu)
 
static void kvm_xen_runstate_set_preempted (struct kvm_vcpu *vcpu)
 
struct compat_vcpu_runstate_info __attribute__ ((packed))
 

Variables

int state
 
uint64_t state_entry_time
 
uint64_t time [4]
 
struct compat_sched_poll __attribute__
 

Macro Definition Documentation

◆ COMPAT_EVTCHN_2L_NR_CHANNELS

#define COMPAT_EVTCHN_2L_NR_CHANNELS
Value:
(8 * \
sizeof_field(struct compat_shared_info, \
evtchn_pending))
compat_shared_info
Definition: xen.h:218

Definition at line 226 of file xen.h.

Function Documentation

◆ __attribute__()

struct compat_vcpu_runstate_info __attribute__ ( (packed)  )
Here is the call graph for this function:

◆ kvm_xen_destroy_vcpu()

static void kvm_xen_destroy_vcpu ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 114 of file xen.h.

115 {
116 }

◆ kvm_xen_destroy_vm()

static void kvm_xen_destroy_vm ( struct kvm *  kvm)
inlinestatic

Definition at line 106 of file xen.h.

107 {
108 }

◆ kvm_xen_has_interrupt()

static int kvm_xen_has_interrupt ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 132 of file xen.h.

133 {
134  return 0;
135 }
Here is the caller graph for this function:

◆ kvm_xen_has_pending_events()

static bool kvm_xen_has_pending_events ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 141 of file xen.h.

142 {
143  return false;
144 }
Here is the caller graph for this function:

◆ kvm_xen_has_pending_timer()

static int kvm_xen_has_pending_timer ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 146 of file xen.h.

147 {
148  return 0;
149 }
Here is the caller graph for this function:

◆ kvm_xen_hypercall()

int kvm_xen_hypercall ( struct kvm_vcpu *  vcpu)

Definition at line 1486 of file xen.c.

1487 {
1488  bool longmode;
1489  u64 input, params[6], r = -ENOSYS;
1490  bool handled = false;
1491  u8 cpl;
1492 
1493  input = (u64)kvm_register_read(vcpu, VCPU_REGS_RAX);
1494 
1495  /* Hyper-V hypercalls get bit 31 set in EAX */
1496  if ((input & 0x80000000) &&
1497  kvm_hv_hypercall_enabled(vcpu))
1498  return kvm_hv_hypercall(vcpu);
1499 
1500  longmode = is_64_bit_hypercall(vcpu);
1501  if (!longmode) {
1502  params[0] = (u32)kvm_rbx_read(vcpu);
1503  params[1] = (u32)kvm_rcx_read(vcpu);
1504  params[2] = (u32)kvm_rdx_read(vcpu);
1505  params[3] = (u32)kvm_rsi_read(vcpu);
1506  params[4] = (u32)kvm_rdi_read(vcpu);
1507  params[5] = (u32)kvm_rbp_read(vcpu);
1508  }
1509 #ifdef CONFIG_X86_64
1510  else {
1511  params[0] = (u64)kvm_rdi_read(vcpu);
1512  params[1] = (u64)kvm_rsi_read(vcpu);
1513  params[2] = (u64)kvm_rdx_read(vcpu);
1514  params[3] = (u64)kvm_r10_read(vcpu);
1515  params[4] = (u64)kvm_r8_read(vcpu);
1516  params[5] = (u64)kvm_r9_read(vcpu);
1517  }
1518 #endif
1519  cpl = static_call(kvm_x86_get_cpl)(vcpu);
1520  trace_kvm_xen_hypercall(cpl, input, params[0], params[1], params[2],
1521  params[3], params[4], params[5]);
1522 
1523  /*
1524  * Only allow hypercall acceleration for CPL0. The rare hypercalls that
1525  * are permitted in guest userspace can be handled by the VMM.
1526  */
1527  if (unlikely(cpl > 0))
1528  goto handle_in_userspace;
1529 
1530  switch (input) {
1531  case __HYPERVISOR_xen_version:
1532  if (params[0] == XENVER_version && vcpu->kvm->arch.xen.xen_version) {
1533  r = vcpu->kvm->arch.xen.xen_version;
1534  handled = true;
1535  }
1536  break;
1537  case __HYPERVISOR_event_channel_op:
1538  if (params[0] == EVTCHNOP_send)
1539  handled = kvm_xen_hcall_evtchn_send(vcpu, params[1], &r);
1540  break;
1541  case __HYPERVISOR_sched_op:
1542  handled = kvm_xen_hcall_sched_op(vcpu, longmode, params[0],
1543  params[1], &r);
1544  break;
1545  case __HYPERVISOR_vcpu_op:
1546  handled = kvm_xen_hcall_vcpu_op(vcpu, longmode, params[0], params[1],
1547  params[2], &r);
1548  break;
1549  case __HYPERVISOR_set_timer_op: {
1550  u64 timeout = params[0];
1551  /* In 32-bit mode, the 64-bit timeout is in two 32-bit params. */
1552  if (!longmode)
1553  timeout |= params[1] << 32;
1554  handled = kvm_xen_hcall_set_timer_op(vcpu, timeout, &r);
1555  break;
1556  }
1557  default:
1558  break;
1559  }
1560 
1561  if (handled)
1562  return kvm_xen_hypercall_set_result(vcpu, r);
1563 
1564 handle_in_userspace:
1565  vcpu->run->exit_reason = KVM_EXIT_XEN;
1566  vcpu->run->xen.type = KVM_EXIT_XEN_HCALL;
1567  vcpu->run->xen.u.hcall.longmode = longmode;
1568  vcpu->run->xen.u.hcall.cpl = cpl;
1569  vcpu->run->xen.u.hcall.input = input;
1570  vcpu->run->xen.u.hcall.params[0] = params[0];
1571  vcpu->run->xen.u.hcall.params[1] = params[1];
1572  vcpu->run->xen.u.hcall.params[2] = params[2];
1573  vcpu->run->xen.u.hcall.params[3] = params[3];
1574  vcpu->run->xen.u.hcall.params[4] = params[4];
1575  vcpu->run->xen.u.hcall.params[5] = params[5];
1576  vcpu->arch.xen.hypercall_rip = kvm_get_linear_rip(vcpu);
1577  vcpu->arch.complete_userspace_io =
1578  kvm_xen_hypercall_complete_userspace;
1579 
1580  return 0;
1581 }
kvm_hv_hypercall
int kvm_hv_hypercall(struct kvm_vcpu *vcpu)
Definition: hyperv.c:2519
kvm_hv_hypercall_enabled
static bool kvm_hv_hypercall_enabled(struct kvm_vcpu *vcpu)
Definition: hyperv.h:280
kvm_get_linear_rip
unsigned long kvm_get_linear_rip(struct kvm_vcpu *vcpu)
Definition: x86.c:13151
kvm_register_read
static unsigned long kvm_register_read(struct kvm_vcpu *vcpu, int reg)
Definition: x86.h:273
is_64_bit_hypercall
static bool is_64_bit_hypercall(struct kvm_vcpu *vcpu)
Definition: x86.h:164
kvm_xen_hypercall_complete_userspace
static int kvm_xen_hypercall_complete_userspace(struct kvm_vcpu *vcpu)
Definition: xen.c:1205
kvm_xen_hcall_evtchn_send
static bool kvm_xen_hcall_evtchn_send(struct kvm_vcpu *vcpu, u64 param, u64 *r)
Definition: xen.c:2070
kvm_xen_hcall_vcpu_op
static bool kvm_xen_hcall_vcpu_op(struct kvm_vcpu *vcpu, bool longmode, int cmd, int vcpu_id, u64 param, u64 *r)
Definition: xen.c:1394
kvm_xen_hcall_set_timer_op
static bool kvm_xen_hcall_set_timer_op(struct kvm_vcpu *vcpu, uint64_t timeout, u64 *r)
Definition: xen.c:1452
kvm_xen_hypercall_set_result
static int kvm_xen_hypercall_set_result(struct kvm_vcpu *vcpu, u64 result)
Definition: xen.c:1199
kvm_xen_hcall_sched_op
static bool kvm_xen_hcall_sched_op(struct kvm_vcpu *vcpu, bool longmode, int cmd, u64 param, u64 *r)
Definition: xen.c:1370
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kvm_xen_hypercall_enabled()

static bool kvm_xen_hypercall_enabled ( struct kvm *  kvm)
inlinestatic

Definition at line 127 of file xen.h.

128 {
129  return false;
130 }
Here is the caller graph for this function:

◆ kvm_xen_init_vcpu()

static void kvm_xen_init_vcpu ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 110 of file xen.h.

111 {
112 }

◆ kvm_xen_init_vm()

static void kvm_xen_init_vm ( struct kvm *  kvm)
inlinestatic

Definition at line 102 of file xen.h.

103 {
104 }

◆ kvm_xen_inject_pending_events()

static void kvm_xen_inject_pending_events ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 137 of file xen.h.

138 {
139 }

◆ kvm_xen_inject_timer_irqs()

static void kvm_xen_inject_timer_irqs ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 151 of file xen.h.

152 {
153 }

◆ kvm_xen_msr_enabled()

static bool kvm_xen_msr_enabled ( struct kvm *  kvm)
inlinestatic

Definition at line 122 of file xen.h.

123 {
124  return false;
125 }
Here is the caller graph for this function:

◆ kvm_xen_runstate_set_preempted()

static void kvm_xen_runstate_set_preempted ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 178 of file xen.h.

179 {
180  /*
181  * If the vCPU wasn't preempted but took a normal exit for
182  * some reason (hypercalls, I/O, etc.), that is accounted as
183  * still RUNSTATE_running, as the VMM is still operating on
184  * behalf of the vCPU. Only if the VMM does actually block
185  * does it need to enter RUNSTATE_blocked.
186  */
187  if (WARN_ON_ONCE(!vcpu->preempted))
188  return;
189 
190  kvm_xen_update_runstate(vcpu, RUNSTATE_runnable);
191 }
kvm_xen_update_runstate
void kvm_xen_update_runstate(struct kvm_vcpu *vcpu, int state)
Definition: xen.c:465
Here is the caller graph for this function:

◆ kvm_xen_runstate_set_running()

static void kvm_xen_runstate_set_running ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 173 of file xen.h.

174 {
175  kvm_xen_update_runstate(vcpu, RUNSTATE_running);
176 }
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kvm_xen_sw_enable_lapic()

static void kvm_xen_sw_enable_lapic ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 118 of file xen.h.

119 {
120 }
Here is the caller graph for this function:

◆ kvm_xen_timer_enabled()

static bool kvm_xen_timer_enabled ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 155 of file xen.h.

156 {
157  return false;
158 }
Here is the caller graph for this function:

◆ kvm_xen_update_runstate()

void kvm_xen_update_runstate ( struct kvm_vcpu *  vcpu,
int  state 
)

Definition at line 465 of file xen.c.

466 {
467  struct kvm_vcpu_xen *vx = &v->arch.xen;
468  u64 now = get_kvmclock_ns(v->kvm);
469  u64 delta_ns = now - vx->runstate_entry_time;
470  u64 run_delay = current->sched_info.run_delay;
471 
472  if (unlikely(!vx->runstate_entry_time))
473  vx->current_runstate = RUNSTATE_offline;
474 
475  /*
476  * Time waiting for the scheduler isn't "stolen" if the
477  * vCPU wasn't running anyway.
478  */
479  if (vx->current_runstate == RUNSTATE_running) {
480  u64 steal_ns = run_delay - vx->last_steal;
481 
482  delta_ns -= steal_ns;
483 
484  vx->runstate_times[RUNSTATE_runnable] += steal_ns;
485  }
486  vx->last_steal = run_delay;
487 
488  vx->runstate_times[vx->current_runstate] += delta_ns;
489  vx->current_runstate = state;
490  vx->runstate_entry_time = now;
491 
492  if (vx->runstate_cache.active)
493  kvm_xen_update_runstate_guest(v, state == RUNSTATE_runnable);
494 }
get_kvmclock_ns
u64 get_kvmclock_ns(struct kvm *kvm)
Definition: x86.c:3105
kvm_xen_update_runstate_guest
static void kvm_xen_update_runstate_guest(struct kvm_vcpu *v, bool atomic)
Definition: xen.c:198
state
int state
Definition: xen.h:0
Here is the call graph for this function:
Here is the caller graph for this function:

◆ kvm_xen_update_tsc_info()

static void kvm_xen_update_tsc_info ( struct kvm_vcpu *  vcpu)
inlinestatic

Definition at line 160 of file xen.h.

161 {
162 }

◆ kvm_xen_write_hypercall_page()

static int kvm_xen_write_hypercall_page ( struct kvm_vcpu *  vcpu,
u64  data 
)
inlinestatic

Definition at line 97 of file xen.h.

98 {
99  return 1;
100 }

Variable Documentation

◆ __attribute__

struct compat_sched_poll __attribute__

◆ state

int state

Definition at line 0 of file xen.h.

◆ state_entry_time

uint64_t state_entry_time

Definition at line 1 of file xen.h.

◆ time

uint64_t time[4]

Definition at line 2 of file xen.h.

Generated by doxygen 1.9.1