← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to arch/x86/include/asm/kvm_para.h

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/x86/include/asm/kvm_para.h
 
1
#ifndef _ASM_X86_KVM_PARA_H
 
2
#define _ASM_X86_KVM_PARA_H
 
3
 
 
4
#include <linux/types.h>
 
5
#include <asm/hyperv.h>
 
6
 
 
7
/* This CPUID returns the signature 'KVMKVMKVM' in ebx, ecx, and edx.  It
 
8
 * should be used to determine that a VM is running under KVM.
 
9
 */
 
10
#define KVM_CPUID_SIGNATURE     0x40000000
 
11
 
 
12
/* This CPUID returns a feature bitmap in eax.  Before enabling a particular
 
13
 * paravirtualization, the appropriate feature bit should be checked.
 
14
 */
 
15
#define KVM_CPUID_FEATURES      0x40000001
 
16
#define KVM_FEATURE_CLOCKSOURCE         0
 
17
#define KVM_FEATURE_NOP_IO_DELAY        1
 
18
#define KVM_FEATURE_MMU_OP              2
 
19
/* This indicates that the new set of kvmclock msrs
 
20
 * are available. The use of 0x11 and 0x12 is deprecated
 
21
 */
 
22
#define KVM_FEATURE_CLOCKSOURCE2        3
 
23
#define KVM_FEATURE_ASYNC_PF            4
 
24
#define KVM_FEATURE_STEAL_TIME          5
 
25
 
 
26
/* The last 8 bits are used to indicate how to interpret the flags field
 
27
 * in pvclock structure. If no bits are set, all flags are ignored.
 
28
 */
 
29
#define KVM_FEATURE_CLOCKSOURCE_STABLE_BIT      24
 
30
 
 
31
#define MSR_KVM_WALL_CLOCK  0x11
 
32
#define MSR_KVM_SYSTEM_TIME 0x12
 
33
 
 
34
#define KVM_MSR_ENABLED 1
 
35
/* Custom MSRs falls in the range 0x4b564d00-0x4b564dff */
 
36
#define MSR_KVM_WALL_CLOCK_NEW  0x4b564d00
 
37
#define MSR_KVM_SYSTEM_TIME_NEW 0x4b564d01
 
38
#define MSR_KVM_ASYNC_PF_EN 0x4b564d02
 
39
#define MSR_KVM_STEAL_TIME  0x4b564d03
 
40
 
 
41
struct kvm_steal_time {
 
42
        __u64 steal;
 
43
        __u32 version;
 
44
        __u32 flags;
 
45
        __u32 pad[12];
 
46
};
 
47
 
 
48
#define KVM_STEAL_ALIGNMENT_BITS 5
 
49
#define KVM_STEAL_VALID_BITS ((-1ULL << (KVM_STEAL_ALIGNMENT_BITS + 1)))
 
50
#define KVM_STEAL_RESERVED_MASK (((1 << KVM_STEAL_ALIGNMENT_BITS) - 1 ) << 1)
 
51
 
 
52
#define KVM_MAX_MMU_OP_BATCH           32
 
53
 
 
54
#define KVM_ASYNC_PF_ENABLED                    (1 << 0)
 
55
#define KVM_ASYNC_PF_SEND_ALWAYS                (1 << 1)
 
56
 
 
57
/* Operations for KVM_HC_MMU_OP */
 
58
#define KVM_MMU_OP_WRITE_PTE            1
 
59
#define KVM_MMU_OP_FLUSH_TLB            2
 
60
#define KVM_MMU_OP_RELEASE_PT           3
 
61
 
 
62
/* Payload for KVM_HC_MMU_OP */
 
63
struct kvm_mmu_op_header {
 
64
        __u32 op;
 
65
        __u32 pad;
 
66
};
 
67
 
 
68
struct kvm_mmu_op_write_pte {
 
69
        struct kvm_mmu_op_header header;
 
70
        __u64 pte_phys;
 
71
        __u64 pte_val;
 
72
};
 
73
 
 
74
struct kvm_mmu_op_flush_tlb {
 
75
        struct kvm_mmu_op_header header;
 
76
};
 
77
 
 
78
struct kvm_mmu_op_release_pt {
 
79
        struct kvm_mmu_op_header header;
 
80
        __u64 pt_phys;
 
81
};
 
82
 
 
83
#define KVM_PV_REASON_PAGE_NOT_PRESENT 1
 
84
#define KVM_PV_REASON_PAGE_READY 2
 
85
 
 
86
struct kvm_vcpu_pv_apf_data {
 
87
        __u32 reason;
 
88
        __u8 pad[60];
 
89
        __u32 enabled;
 
90
};
 
91
 
 
92
#ifdef __KERNEL__
 
93
#include <asm/processor.h>
 
94
 
 
95
extern void kvmclock_init(void);
 
96
extern int kvm_register_clock(char *txt);
 
97
 
 
98
 
 
99
/* This instruction is vmcall.  On non-VT architectures, it will generate a
 
100
 * trap that we will then rewrite to the appropriate instruction.
 
101
 */
 
102
#define KVM_HYPERCALL ".byte 0x0f,0x01,0xc1"
 
103
 
 
104
/* For KVM hypercalls, a three-byte sequence of either the vmrun or the vmmrun
 
105
 * instruction.  The hypervisor may replace it with something else but only the
 
106
 * instructions are guaranteed to be supported.
 
107
 *
 
108
 * Up to four arguments may be passed in rbx, rcx, rdx, and rsi respectively.
 
109
 * The hypercall number should be placed in rax and the return value will be
 
110
 * placed in rax.  No other registers will be clobbered unless explicited
 
111
 * noted by the particular hypercall.
 
112
 */
 
113
 
 
114
static inline long kvm_hypercall0(unsigned int nr)
 
115
{
 
116
        long ret;
 
117
        asm volatile(KVM_HYPERCALL
 
118
                     : "=a"(ret)
 
119
                     : "a"(nr)
 
120
                     : "memory");
 
121
        return ret;
 
122
}
 
123
 
 
124
static inline long kvm_hypercall1(unsigned int nr, unsigned long p1)
 
125
{
 
126
        long ret;
 
127
        asm volatile(KVM_HYPERCALL
 
128
                     : "=a"(ret)
 
129
                     : "a"(nr), "b"(p1)
 
130
                     : "memory");
 
131
        return ret;
 
132
}
 
133
 
 
134
static inline long kvm_hypercall2(unsigned int nr, unsigned long p1,
 
135
                                  unsigned long p2)
 
136
{
 
137
        long ret;
 
138
        asm volatile(KVM_HYPERCALL
 
139
                     : "=a"(ret)
 
140
                     : "a"(nr), "b"(p1), "c"(p2)
 
141
                     : "memory");
 
142
        return ret;
 
143
}
 
144
 
 
145
static inline long kvm_hypercall3(unsigned int nr, unsigned long p1,
 
146
                                  unsigned long p2, unsigned long p3)
 
147
{
 
148
        long ret;
 
149
        asm volatile(KVM_HYPERCALL
 
150
                     : "=a"(ret)
 
151
                     : "a"(nr), "b"(p1), "c"(p2), "d"(p3)
 
152
                     : "memory");
 
153
        return ret;
 
154
}
 
155
 
 
156
static inline long kvm_hypercall4(unsigned int nr, unsigned long p1,
 
157
                                  unsigned long p2, unsigned long p3,
 
158
                                  unsigned long p4)
 
159
{
 
160
        long ret;
 
161
        asm volatile(KVM_HYPERCALL
 
162
                     : "=a"(ret)
 
163
                     : "a"(nr), "b"(p1), "c"(p2), "d"(p3), "S"(p4)
 
164
                     : "memory");
 
165
        return ret;
 
166
}
 
167
 
 
168
static inline int kvm_para_available(void)
 
169
{
 
170
        unsigned int eax, ebx, ecx, edx;
 
171
        char signature[13];
 
172
 
 
173
        cpuid(KVM_CPUID_SIGNATURE, &eax, &ebx, &ecx, &edx);
 
174
        memcpy(signature + 0, &ebx, 4);
 
175
        memcpy(signature + 4, &ecx, 4);
 
176
        memcpy(signature + 8, &edx, 4);
 
177
        signature[12] = 0;
 
178
 
 
179
        if (strcmp(signature, "KVMKVMKVM") == 0)
 
180
                return 1;
 
181
 
 
182
        return 0;
 
183
}
 
184
 
 
185
static inline unsigned int kvm_arch_para_features(void)
 
186
{
 
187
        return cpuid_eax(KVM_CPUID_FEATURES);
 
188
}
 
189
 
 
190
#ifdef CONFIG_KVM_GUEST
 
191
void __init kvm_guest_init(void);
 
192
void kvm_async_pf_task_wait(u32 token);
 
193
void kvm_async_pf_task_wake(u32 token);
 
194
u32 kvm_read_and_reset_pf_reason(void);
 
195
extern void kvm_disable_steal_time(void);
 
196
#else
 
197
#define kvm_guest_init() do { } while (0)
 
198
#define kvm_async_pf_task_wait(T) do {} while(0)
 
199
#define kvm_async_pf_task_wake(T) do {} while(0)
 
200
static inline u32 kvm_read_and_reset_pf_reason(void)
 
201
{
 
202
        return 0;
 
203
}
 
204
 
 
205
static inline void kvm_disable_steal_time(void)
 
206
{
 
207
        return;
 
208
}
 
209
#endif
 
210
 
 
211
#endif /* __KERNEL__ */
 
212
 
 
213
#endif /* _ASM_X86_KVM_PARA_H */