Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 1 | #!/usr/bin/python |
| 2 | # |
| 3 | # tool for querying VMX capabilities |
| 4 | # |
| 5 | # Copyright 2009-2010 Red Hat, Inc. |
| 6 | # |
| 7 | # Authors: |
| 8 | # Avi Kivity <avi@redhat.com> |
| 9 | # |
| 10 | # This work is licensed under the terms of the GNU GPL, version 2. See |
| 11 | # the COPYING file in the top-level directory. |
| 12 | |
| 13 | MSR_IA32_VMX_BASIC = 0x480 |
| 14 | MSR_IA32_VMX_PINBASED_CTLS = 0x481 |
| 15 | MSR_IA32_VMX_PROCBASED_CTLS = 0x482 |
| 16 | MSR_IA32_VMX_EXIT_CTLS = 0x483 |
| 17 | MSR_IA32_VMX_ENTRY_CTLS = 0x484 |
| 18 | MSR_IA32_VMX_MISC_CTLS = 0x485 |
| 19 | MSR_IA32_VMX_PROCBASED_CTLS2 = 0x48B |
| 20 | MSR_IA32_VMX_EPT_VPID_CAP = 0x48C |
| 21 | MSR_IA32_VMX_TRUE_PINBASED_CTLS = 0x48D |
| 22 | MSR_IA32_VMX_TRUE_PROCBASED_CTLS = 0x48E |
| 23 | MSR_IA32_VMX_TRUE_EXIT_CTLS = 0x48F |
| 24 | MSR_IA32_VMX_TRUE_ENTRY_CTLS = 0x490 |
Avi Kivity | 287d55c | 2012-05-16 14:31:37 +0300 | [diff] [blame] | 25 | MSR_IA32_VMX_VMFUNC = 0x491 |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 26 | |
| 27 | class msr(object): |
| 28 | def __init__(self): |
| 29 | try: |
Jan Kiszka | f505a4d | 2013-02-13 12:43:10 +0100 | [diff] [blame] | 30 | self.f = open('/dev/cpu/0/msr', 'r', 0) |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 31 | except: |
Jan Kiszka | f505a4d | 2013-02-13 12:43:10 +0100 | [diff] [blame] | 32 | self.f = open('/dev/msr0', 'r', 0) |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 33 | def read(self, index, default = None): |
| 34 | import struct |
| 35 | self.f.seek(index) |
| 36 | try: |
| 37 | return struct.unpack('Q', self.f.read(8))[0] |
| 38 | except: |
| 39 | return default |
| 40 | |
| 41 | class Control(object): |
| 42 | def __init__(self, name, bits, cap_msr, true_cap_msr = None): |
| 43 | self.name = name |
| 44 | self.bits = bits |
| 45 | self.cap_msr = cap_msr |
| 46 | self.true_cap_msr = true_cap_msr |
| 47 | def read2(self, nr): |
| 48 | m = msr() |
| 49 | val = m.read(nr, 0) |
| 50 | return (val & 0xffffffff, val >> 32) |
| 51 | def show(self): |
| 52 | print self.name |
| 53 | mbz, mb1 = self.read2(self.cap_msr) |
| 54 | tmbz, tmb1 = 0, 0 |
| 55 | if self.true_cap_msr: |
| 56 | tmbz, tmb1 = self.read2(self.true_cap_msr) |
| 57 | for bit in sorted(self.bits.keys()): |
| 58 | zero = not (mbz & (1 << bit)) |
| 59 | one = mb1 & (1 << bit) |
| 60 | true_zero = not (tmbz & (1 << bit)) |
| 61 | true_one = tmb1 & (1 << bit) |
| 62 | s= '?' |
| 63 | if (self.true_cap_msr and true_zero and true_one |
| 64 | and one and not zero): |
| 65 | s = 'default' |
| 66 | elif zero and not one: |
| 67 | s = 'no' |
| 68 | elif one and not zero: |
| 69 | s = 'forced' |
| 70 | elif one and zero: |
| 71 | s = 'yes' |
| 72 | print ' %-40s %s' % (self.bits[bit], s) |
| 73 | |
| 74 | class Misc(object): |
| 75 | def __init__(self, name, bits, msr): |
| 76 | self.name = name |
| 77 | self.bits = bits |
| 78 | self.msr = msr |
| 79 | def show(self): |
| 80 | print self.name |
| 81 | value = msr().read(self.msr, 0) |
| 82 | def first_bit(key): |
| 83 | if type(key) is tuple: |
| 84 | return key[0] |
| 85 | else: |
| 86 | return key |
| 87 | for bits in sorted(self.bits.keys(), key = first_bit): |
| 88 | if type(bits) is tuple: |
| 89 | lo, hi = bits |
| 90 | fmt = int |
| 91 | else: |
| 92 | lo = hi = bits |
| 93 | def fmt(x): |
| 94 | return { True: 'yes', False: 'no' }[x] |
| 95 | v = (value >> lo) & ((1 << (hi - lo + 1)) - 1) |
| 96 | print ' %-40s %s' % (self.bits[bits], fmt(v)) |
| 97 | |
| 98 | controls = [ |
Jan Kiszka | ea4ee28 | 2013-02-13 12:44:06 +0100 | [diff] [blame] | 99 | Misc( |
| 100 | name = 'Basic VMX Information', |
| 101 | bits = { |
| 102 | (0, 31): 'Revision', |
| 103 | (32,44): 'VMCS size', |
| 104 | 48: 'VMCS restricted to 32 bit addresses', |
| 105 | 49: 'Dual-monitor support', |
| 106 | (50, 53): 'VMCS memory type', |
| 107 | 54: 'INS/OUTS instruction information', |
| 108 | 55: 'IA32_VMX_TRUE_*_CTLS support', |
| 109 | }, |
| 110 | msr = MSR_IA32_VMX_BASIC, |
| 111 | ), |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 112 | Control( |
| 113 | name = 'pin-based controls', |
| 114 | bits = { |
| 115 | 0: 'External interrupt exiting', |
| 116 | 3: 'NMI exiting', |
| 117 | 5: 'Virtual NMIs', |
| 118 | 6: 'Activate VMX-preemption timer', |
Jan Kiszka | ea4ee28 | 2013-02-13 12:44:06 +0100 | [diff] [blame] | 119 | 7: 'Process posted interrupts', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 120 | }, |
| 121 | cap_msr = MSR_IA32_VMX_PINBASED_CTLS, |
| 122 | true_cap_msr = MSR_IA32_VMX_TRUE_PINBASED_CTLS, |
| 123 | ), |
| 124 | |
| 125 | Control( |
| 126 | name = 'primary processor-based controls', |
| 127 | bits = { |
| 128 | 2: 'Interrupt window exiting', |
| 129 | 3: 'Use TSC offsetting', |
| 130 | 7: 'HLT exiting', |
| 131 | 9: 'INVLPG exiting', |
| 132 | 10: 'MWAIT exiting', |
| 133 | 11: 'RDPMC exiting', |
| 134 | 12: 'RDTSC exiting', |
| 135 | 15: 'CR3-load exiting', |
| 136 | 16: 'CR3-store exiting', |
| 137 | 19: 'CR8-load exiting', |
| 138 | 20: 'CR8-store exiting', |
| 139 | 21: 'Use TPR shadow', |
| 140 | 22: 'NMI-window exiting', |
| 141 | 23: 'MOV-DR exiting', |
| 142 | 24: 'Unconditional I/O exiting', |
| 143 | 25: 'Use I/O bitmaps', |
| 144 | 27: 'Monitor trap flag', |
| 145 | 28: 'Use MSR bitmaps', |
| 146 | 29: 'MONITOR exiting', |
| 147 | 30: 'PAUSE exiting', |
| 148 | 31: 'Activate secondary control', |
| 149 | }, |
| 150 | cap_msr = MSR_IA32_VMX_PROCBASED_CTLS, |
| 151 | true_cap_msr = MSR_IA32_VMX_TRUE_PROCBASED_CTLS, |
| 152 | ), |
| 153 | |
| 154 | Control( |
| 155 | name = 'secondary processor-based controls', |
| 156 | bits = { |
| 157 | 0: 'Virtualize APIC accesses', |
| 158 | 1: 'Enable EPT', |
| 159 | 2: 'Descriptor-table exiting', |
Jan Kiszka | 614413f | 2013-02-18 07:56:54 +0100 | [diff] [blame] | 160 | 3: 'Enable RDTSCP', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 161 | 4: 'Virtualize x2APIC mode', |
| 162 | 5: 'Enable VPID', |
| 163 | 6: 'WBINVD exiting', |
| 164 | 7: 'Unrestricted guest', |
Jan Kiszka | 614413f | 2013-02-18 07:56:54 +0100 | [diff] [blame] | 165 | 8: 'APIC register emulation', |
Marcelo Tosatti | f9e90c7 | 2013-01-10 23:02:48 -0200 | [diff] [blame] | 166 | 9: 'Virtual interrupt delivery', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 167 | 10: 'PAUSE-loop exiting', |
Avi Kivity | 287d55c | 2012-05-16 14:31:37 +0300 | [diff] [blame] | 168 | 11: 'RDRAND exiting', |
| 169 | 12: 'Enable INVPCID', |
| 170 | 13: 'Enable VM functions', |
Jan Kiszka | 007e986 | 2013-03-17 11:45:50 +0100 | [diff] [blame^] | 171 | 14: 'VMCS shadowing', |
| 172 | 18: 'EPT-violation #VE' |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 173 | }, |
| 174 | cap_msr = MSR_IA32_VMX_PROCBASED_CTLS2, |
| 175 | ), |
| 176 | |
| 177 | Control( |
| 178 | name = 'VM-Exit controls', |
| 179 | bits = { |
| 180 | 2: 'Save debug controls', |
| 181 | 9: 'Host address-space size', |
| 182 | 12: 'Load IA32_PERF_GLOBAL_CTRL', |
| 183 | 15: 'Acknowledge interrupt on exit', |
| 184 | 18: 'Save IA32_PAT', |
| 185 | 19: 'Load IA32_PAT', |
| 186 | 20: 'Save IA32_EFER', |
| 187 | 21: 'Load IA32_EFER', |
| 188 | 22: 'Save VMX-preemption timer value', |
| 189 | }, |
| 190 | cap_msr = MSR_IA32_VMX_EXIT_CTLS, |
| 191 | true_cap_msr = MSR_IA32_VMX_TRUE_EXIT_CTLS, |
| 192 | ), |
| 193 | |
| 194 | Control( |
| 195 | name = 'VM-Entry controls', |
| 196 | bits = { |
| 197 | 2: 'Load debug controls', |
| 198 | 9: 'IA-64 mode guest', |
| 199 | 10: 'Entry to SMM', |
| 200 | 11: 'Deactivate dual-monitor treatment', |
| 201 | 13: 'Load IA32_PERF_GLOBAL_CTRL', |
| 202 | 14: 'Load IA32_PAT', |
| 203 | 15: 'Load IA32_EFER', |
| 204 | }, |
| 205 | cap_msr = MSR_IA32_VMX_ENTRY_CTLS, |
| 206 | true_cap_msr = MSR_IA32_VMX_TRUE_ENTRY_CTLS, |
| 207 | ), |
| 208 | |
| 209 | Misc( |
| 210 | name = 'Miscellaneous data', |
| 211 | bits = { |
| 212 | (0,4): 'VMX-preemption timer scale (log2)', |
| 213 | 5: 'Store EFER.LMA into IA-32e mode guest control', |
| 214 | 6: 'HLT activity state', |
| 215 | 7: 'Shutdown activity state', |
| 216 | 8: 'Wait-for-SIPI activity state', |
Jan Kiszka | 007e986 | 2013-03-17 11:45:50 +0100 | [diff] [blame^] | 217 | 15: 'IA32_SMBASE support', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 218 | (16,24): 'Number of CR3-target values', |
| 219 | (25,27): 'MSR-load/store count recommenation', |
Avi Kivity | 287d55c | 2012-05-16 14:31:37 +0300 | [diff] [blame] | 220 | 28: 'IA32_SMM_MONITOR_CTL[2] can be set to 1', |
Jan Kiszka | 007e986 | 2013-03-17 11:45:50 +0100 | [diff] [blame^] | 221 | 29: 'VMWRITE to VM-exit information fields', |
| 222 | (32,63): 'MSEG revision identifier', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 223 | }, |
| 224 | msr = MSR_IA32_VMX_MISC_CTLS, |
| 225 | ), |
| 226 | |
| 227 | Misc( |
| 228 | name = 'VPID and EPT capabilities', |
| 229 | bits = { |
| 230 | 0: 'Execute-only EPT translations', |
| 231 | 6: 'Page-walk length 4', |
| 232 | 8: 'Paging-structure memory type UC', |
| 233 | 14: 'Paging-structure memory type WB', |
| 234 | 16: '2MB EPT pages', |
| 235 | 17: '1GB EPT pages', |
| 236 | 20: 'INVEPT supported', |
Avi Kivity | 287d55c | 2012-05-16 14:31:37 +0300 | [diff] [blame] | 237 | 21: 'EPT accessed and dirty flags', |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 238 | 25: 'Single-context INVEPT', |
| 239 | 26: 'All-context INVEPT', |
| 240 | 32: 'INVVPID supported', |
| 241 | 40: 'Individual-address INVVPID', |
| 242 | 41: 'Single-context INVVPID', |
| 243 | 42: 'All-context INVVPID', |
| 244 | 43: 'Single-context-retaining-globals INVVPID', |
| 245 | }, |
| 246 | msr = MSR_IA32_VMX_EPT_VPID_CAP, |
| 247 | ), |
Avi Kivity | 287d55c | 2012-05-16 14:31:37 +0300 | [diff] [blame] | 248 | Misc( |
| 249 | name = 'VM Functions', |
| 250 | bits = { |
| 251 | 0: 'EPTP Switching', |
| 252 | }, |
| 253 | msr = MSR_IA32_VMX_VMFUNC, |
| 254 | ), |
Jan Kiszka | 5f6caa4 | 2011-10-07 09:37:57 +0200 | [diff] [blame] | 255 | ] |
| 256 | |
| 257 | for c in controls: |
| 258 | c.show() |