1 /****************************************************************************** 2 * domctl.h 3 * 4 * Domain management operations. For use by node control stack. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to 8 * deal in the Software without restriction, including without limitation the 9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 * sell copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Copyright (c) 2002-2003, B Dragovic 25 * Copyright (c) 2002-2006, K Fraser 26 */ 27 28 #ifndef __XEN_PUBLIC_DOMCTL_H__ 29 #define __XEN_PUBLIC_DOMCTL_H__ 30 31 #if !defined(__XEN__) && !defined(__XEN_TOOLS__) 32 #error "domctl operations are intended for use by node control tools only" 33 #endif 34 35 #include "xen.h" 36 #include "grant_table.h" 37 #include "hvm/save.h" 38 #include "memory.h" 39 40 #define XEN_DOMCTL_INTERFACE_VERSION 0x0000000b 41 42 /* 43 * NB. xen_domctl.domain is an IN/OUT parameter for this operation. 44 * If it is specified as zero, an id is auto-allocated and returned. 45 */ 46 /* XEN_DOMCTL_createdomain */ 47 struct xen_domctl_createdomain { 48 /* IN parameters */ 49 uint32_t ssidref; 50 xen_domain_handle_t handle; 51 /* Is this an HVM guest (as opposed to a PVH or PV guest)? */ 52 #define _XEN_DOMCTL_CDF_hvm_guest 0 53 #define XEN_DOMCTL_CDF_hvm_guest (1U<<_XEN_DOMCTL_CDF_hvm_guest) 54 /* Use hardware-assisted paging if available? */ 55 #define _XEN_DOMCTL_CDF_hap 1 56 #define XEN_DOMCTL_CDF_hap (1U<<_XEN_DOMCTL_CDF_hap) 57 /* Should domain memory integrity be verifed by tboot during Sx? */ 58 #define _XEN_DOMCTL_CDF_s3_integrity 2 59 #define XEN_DOMCTL_CDF_s3_integrity (1U<<_XEN_DOMCTL_CDF_s3_integrity) 60 /* Disable out-of-sync shadow page tables? */ 61 #define _XEN_DOMCTL_CDF_oos_off 3 62 #define XEN_DOMCTL_CDF_oos_off (1U<<_XEN_DOMCTL_CDF_oos_off) 63 /* Is this a PVH guest (as opposed to an HVM or PV guest)? */ 64 #define _XEN_DOMCTL_CDF_pvh_guest 4 65 #define XEN_DOMCTL_CDF_pvh_guest (1U<<_XEN_DOMCTL_CDF_pvh_guest) 66 uint32_t flags; 67 struct xen_arch_domainconfig config; 68 }; 69 typedef struct xen_domctl_createdomain xen_domctl_createdomain_t; 70 DEFINE_XEN_GUEST_HANDLE(xen_domctl_createdomain_t); 71 72 /* XEN_DOMCTL_getdomaininfo */ 73 struct xen_domctl_getdomaininfo { 74 /* OUT variables. */ 75 domid_t domain; /* Also echoed in domctl.domain */ 76 /* Domain is scheduled to die. */ 77 #define _XEN_DOMINF_dying 0 78 #define XEN_DOMINF_dying (1U<<_XEN_DOMINF_dying) 79 /* Domain is an HVM guest (as opposed to a PV guest). */ 80 #define _XEN_DOMINF_hvm_guest 1 81 #define XEN_DOMINF_hvm_guest (1U<<_XEN_DOMINF_hvm_guest) 82 /* The guest OS has shut down. */ 83 #define _XEN_DOMINF_shutdown 2 84 #define XEN_DOMINF_shutdown (1U<<_XEN_DOMINF_shutdown) 85 /* Currently paused by control software. */ 86 #define _XEN_DOMINF_paused 3 87 #define XEN_DOMINF_paused (1U<<_XEN_DOMINF_paused) 88 /* Currently blocked pending an event. */ 89 #define _XEN_DOMINF_blocked 4 90 #define XEN_DOMINF_blocked (1U<<_XEN_DOMINF_blocked) 91 /* Domain is currently running. */ 92 #define _XEN_DOMINF_running 5 93 #define XEN_DOMINF_running (1U<<_XEN_DOMINF_running) 94 /* Being debugged. */ 95 #define _XEN_DOMINF_debugged 6 96 #define XEN_DOMINF_debugged (1U<<_XEN_DOMINF_debugged) 97 /* domain is PVH */ 98 #define _XEN_DOMINF_pvh_guest 7 99 #define XEN_DOMINF_pvh_guest (1U<<_XEN_DOMINF_pvh_guest) 100 /* XEN_DOMINF_shutdown guest-supplied code. */ 101 #define XEN_DOMINF_shutdownmask 255 102 #define XEN_DOMINF_shutdownshift 16 103 uint32_t flags; /* XEN_DOMINF_* */ 104 uint64_aligned_t tot_pages; 105 uint64_aligned_t max_pages; 106 uint64_aligned_t outstanding_pages; 107 uint64_aligned_t shr_pages; 108 uint64_aligned_t paged_pages; 109 uint64_aligned_t shared_info_frame; /* GMFN of shared_info struct */ 110 uint64_aligned_t cpu_time; 111 uint32_t nr_online_vcpus; /* Number of VCPUs currently online. */ 112 #define XEN_INVALID_MAX_VCPU_ID (~0U) /* Domain has no vcpus? */ 113 uint32_t max_vcpu_id; /* Maximum VCPUID in use by this domain. */ 114 uint32_t ssidref; 115 xen_domain_handle_t handle; 116 uint32_t cpupool; 117 }; 118 typedef struct xen_domctl_getdomaininfo xen_domctl_getdomaininfo_t; 119 DEFINE_XEN_GUEST_HANDLE(xen_domctl_getdomaininfo_t); 120 121 122 /* XEN_DOMCTL_getmemlist */ 123 struct xen_domctl_getmemlist { 124 /* IN variables. */ 125 /* Max entries to write to output buffer. */ 126 uint64_aligned_t max_pfns; 127 /* Start index in guest's page list. */ 128 uint64_aligned_t start_pfn; 129 XEN_GUEST_HANDLE_64(uint64) buffer; 130 /* OUT variables. */ 131 uint64_aligned_t num_pfns; 132 }; 133 typedef struct xen_domctl_getmemlist xen_domctl_getmemlist_t; 134 DEFINE_XEN_GUEST_HANDLE(xen_domctl_getmemlist_t); 135 136 137 /* XEN_DOMCTL_getpageframeinfo */ 138 139 #define XEN_DOMCTL_PFINFO_LTAB_SHIFT 28 140 #define XEN_DOMCTL_PFINFO_NOTAB (0x0U<<28) 141 #define XEN_DOMCTL_PFINFO_L1TAB (0x1U<<28) 142 #define XEN_DOMCTL_PFINFO_L2TAB (0x2U<<28) 143 #define XEN_DOMCTL_PFINFO_L3TAB (0x3U<<28) 144 #define XEN_DOMCTL_PFINFO_L4TAB (0x4U<<28) 145 #define XEN_DOMCTL_PFINFO_LTABTYPE_MASK (0x7U<<28) 146 #define XEN_DOMCTL_PFINFO_LPINTAB (0x1U<<31) 147 #define XEN_DOMCTL_PFINFO_XTAB (0xfU<<28) /* invalid page */ 148 #define XEN_DOMCTL_PFINFO_XALLOC (0xeU<<28) /* allocate-only page */ 149 #define XEN_DOMCTL_PFINFO_BROKEN (0xdU<<28) /* broken page */ 150 #define XEN_DOMCTL_PFINFO_LTAB_MASK (0xfU<<28) 151 152 /* XEN_DOMCTL_getpageframeinfo3 */ 153 struct xen_domctl_getpageframeinfo3 { 154 /* IN variables. */ 155 uint64_aligned_t num; 156 /* IN/OUT variables. */ 157 XEN_GUEST_HANDLE_64(xen_pfn_t) array; 158 }; 159 160 161 /* 162 * Control shadow pagetables operation 163 */ 164 /* XEN_DOMCTL_shadow_op */ 165 166 /* Disable shadow mode. */ 167 #define XEN_DOMCTL_SHADOW_OP_OFF 0 168 169 /* Enable shadow mode (mode contains ORed XEN_DOMCTL_SHADOW_ENABLE_* flags). */ 170 #define XEN_DOMCTL_SHADOW_OP_ENABLE 32 171 172 /* Log-dirty bitmap operations. */ 173 /* Return the bitmap and clean internal copy for next round. */ 174 #define XEN_DOMCTL_SHADOW_OP_CLEAN 11 175 /* Return the bitmap but do not modify internal copy. */ 176 #define XEN_DOMCTL_SHADOW_OP_PEEK 12 177 178 /* Memory allocation accessors. */ 179 #define XEN_DOMCTL_SHADOW_OP_GET_ALLOCATION 30 180 #define XEN_DOMCTL_SHADOW_OP_SET_ALLOCATION 31 181 182 /* Legacy enable operations. */ 183 /* Equiv. to ENABLE with no mode flags. */ 184 #define XEN_DOMCTL_SHADOW_OP_ENABLE_TEST 1 185 /* Equiv. to ENABLE with mode flag ENABLE_LOG_DIRTY. */ 186 #define XEN_DOMCTL_SHADOW_OP_ENABLE_LOGDIRTY 2 187 /* Equiv. to ENABLE with mode flags ENABLE_REFCOUNT and ENABLE_TRANSLATE. */ 188 #define XEN_DOMCTL_SHADOW_OP_ENABLE_TRANSLATE 3 189 190 /* Mode flags for XEN_DOMCTL_SHADOW_OP_ENABLE. */ 191 /* 192 * Shadow pagetables are refcounted: guest does not use explicit mmu 193 * operations nor write-protect its pagetables. 194 */ 195 #define XEN_DOMCTL_SHADOW_ENABLE_REFCOUNT (1 << 1) 196 /* 197 * Log pages in a bitmap as they are dirtied. 198 * Used for live relocation to determine which pages must be re-sent. 199 */ 200 #define XEN_DOMCTL_SHADOW_ENABLE_LOG_DIRTY (1 << 2) 201 /* 202 * Automatically translate GPFNs into MFNs. 203 */ 204 #define XEN_DOMCTL_SHADOW_ENABLE_TRANSLATE (1 << 3) 205 /* 206 * Xen does not steal virtual address space from the guest. 207 * Requires HVM support. 208 */ 209 #define XEN_DOMCTL_SHADOW_ENABLE_EXTERNAL (1 << 4) 210 211 struct xen_domctl_shadow_op_stats { 212 uint32_t fault_count; 213 uint32_t dirty_count; 214 }; 215 typedef struct xen_domctl_shadow_op_stats xen_domctl_shadow_op_stats_t; 216 DEFINE_XEN_GUEST_HANDLE(xen_domctl_shadow_op_stats_t); 217 218 struct xen_domctl_shadow_op { 219 /* IN variables. */ 220 uint32_t op; /* XEN_DOMCTL_SHADOW_OP_* */ 221 222 /* OP_ENABLE */ 223 uint32_t mode; /* XEN_DOMCTL_SHADOW_ENABLE_* */ 224 225 /* OP_GET_ALLOCATION / OP_SET_ALLOCATION */ 226 uint32_t mb; /* Shadow memory allocation in MB */ 227 228 /* OP_PEEK / OP_CLEAN */ 229 XEN_GUEST_HANDLE_64(uint8) dirty_bitmap; 230 uint64_aligned_t pages; /* Size of buffer. Updated with actual size. */ 231 struct xen_domctl_shadow_op_stats stats; 232 }; 233 typedef struct xen_domctl_shadow_op xen_domctl_shadow_op_t; 234 DEFINE_XEN_GUEST_HANDLE(xen_domctl_shadow_op_t); 235 236 237 /* XEN_DOMCTL_max_mem */ 238 struct xen_domctl_max_mem { 239 /* IN variables. */ 240 uint64_aligned_t max_memkb; 241 }; 242 typedef struct xen_domctl_max_mem xen_domctl_max_mem_t; 243 DEFINE_XEN_GUEST_HANDLE(xen_domctl_max_mem_t); 244 245 246 /* XEN_DOMCTL_setvcpucontext */ 247 /* XEN_DOMCTL_getvcpucontext */ 248 struct xen_domctl_vcpucontext { 249 uint32_t vcpu; /* IN */ 250 XEN_GUEST_HANDLE_64(vcpu_guest_context_t) ctxt; /* IN/OUT */ 251 }; 252 typedef struct xen_domctl_vcpucontext xen_domctl_vcpucontext_t; 253 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpucontext_t); 254 255 256 /* XEN_DOMCTL_getvcpuinfo */ 257 struct xen_domctl_getvcpuinfo { 258 /* IN variables. */ 259 uint32_t vcpu; 260 /* OUT variables. */ 261 uint8_t online; /* currently online (not hotplugged)? */ 262 uint8_t blocked; /* blocked waiting for an event? */ 263 uint8_t running; /* currently scheduled on its CPU? */ 264 uint64_aligned_t cpu_time; /* total cpu time consumed (ns) */ 265 uint32_t cpu; /* current mapping */ 266 }; 267 typedef struct xen_domctl_getvcpuinfo xen_domctl_getvcpuinfo_t; 268 DEFINE_XEN_GUEST_HANDLE(xen_domctl_getvcpuinfo_t); 269 270 271 /* Get/set the NUMA node(s) with which the guest has affinity with. */ 272 /* XEN_DOMCTL_setnodeaffinity */ 273 /* XEN_DOMCTL_getnodeaffinity */ 274 struct xen_domctl_nodeaffinity { 275 struct xenctl_bitmap nodemap;/* IN */ 276 }; 277 typedef struct xen_domctl_nodeaffinity xen_domctl_nodeaffinity_t; 278 DEFINE_XEN_GUEST_HANDLE(xen_domctl_nodeaffinity_t); 279 280 281 /* Get/set which physical cpus a vcpu can execute on. */ 282 /* XEN_DOMCTL_setvcpuaffinity */ 283 /* XEN_DOMCTL_getvcpuaffinity */ 284 struct xen_domctl_vcpuaffinity { 285 /* IN variables. */ 286 uint32_t vcpu; 287 /* Set/get the hard affinity for vcpu */ 288 #define _XEN_VCPUAFFINITY_HARD 0 289 #define XEN_VCPUAFFINITY_HARD (1U<<_XEN_VCPUAFFINITY_HARD) 290 /* Set/get the soft affinity for vcpu */ 291 #define _XEN_VCPUAFFINITY_SOFT 1 292 #define XEN_VCPUAFFINITY_SOFT (1U<<_XEN_VCPUAFFINITY_SOFT) 293 uint32_t flags; 294 /* 295 * IN/OUT variables. 296 * 297 * Both are IN/OUT for XEN_DOMCTL_setvcpuaffinity, in which case they 298 * contain effective hard or/and soft affinity. That is, upon successful 299 * return, cpumap_soft, contains the intersection of the soft affinity, 300 * hard affinity and the cpupool's online CPUs for the domain (if 301 * XEN_VCPUAFFINITY_SOFT was set in flags). cpumap_hard contains the 302 * intersection between hard affinity and the cpupool's online CPUs (if 303 * XEN_VCPUAFFINITY_HARD was set in flags). 304 * 305 * Both are OUT-only for XEN_DOMCTL_getvcpuaffinity, in which case they 306 * contain the plain hard and/or soft affinity masks that were set during 307 * previous successful calls to XEN_DOMCTL_setvcpuaffinity (or the 308 * default values), without intersecting or altering them in any way. 309 */ 310 struct xenctl_bitmap cpumap_hard; 311 struct xenctl_bitmap cpumap_soft; 312 }; 313 typedef struct xen_domctl_vcpuaffinity xen_domctl_vcpuaffinity_t; 314 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpuaffinity_t); 315 316 317 /* XEN_DOMCTL_max_vcpus */ 318 struct xen_domctl_max_vcpus { 319 uint32_t max; /* maximum number of vcpus */ 320 }; 321 typedef struct xen_domctl_max_vcpus xen_domctl_max_vcpus_t; 322 DEFINE_XEN_GUEST_HANDLE(xen_domctl_max_vcpus_t); 323 324 325 /* XEN_DOMCTL_scheduler_op */ 326 /* Scheduler types. */ 327 /* #define XEN_SCHEDULER_SEDF 4 (Removed) */ 328 #define XEN_SCHEDULER_CREDIT 5 329 #define XEN_SCHEDULER_CREDIT2 6 330 #define XEN_SCHEDULER_ARINC653 7 331 #define XEN_SCHEDULER_RTDS 8 332 333 /* Set or get info? */ 334 #define XEN_DOMCTL_SCHEDOP_putinfo 0 335 #define XEN_DOMCTL_SCHEDOP_getinfo 1 336 struct xen_domctl_scheduler_op { 337 uint32_t sched_id; /* XEN_SCHEDULER_* */ 338 uint32_t cmd; /* XEN_DOMCTL_SCHEDOP_* */ 339 union { 340 struct xen_domctl_sched_credit { 341 uint16_t weight; 342 uint16_t cap; 343 } credit; 344 struct xen_domctl_sched_credit2 { 345 uint16_t weight; 346 } credit2; 347 struct xen_domctl_sched_rtds { 348 uint32_t period; 349 uint32_t budget; 350 } rtds; 351 } u; 352 }; 353 typedef struct xen_domctl_scheduler_op xen_domctl_scheduler_op_t; 354 DEFINE_XEN_GUEST_HANDLE(xen_domctl_scheduler_op_t); 355 356 357 /* XEN_DOMCTL_setdomainhandle */ 358 struct xen_domctl_setdomainhandle { 359 xen_domain_handle_t handle; 360 }; 361 typedef struct xen_domctl_setdomainhandle xen_domctl_setdomainhandle_t; 362 DEFINE_XEN_GUEST_HANDLE(xen_domctl_setdomainhandle_t); 363 364 365 /* XEN_DOMCTL_setdebugging */ 366 struct xen_domctl_setdebugging { 367 uint8_t enable; 368 }; 369 typedef struct xen_domctl_setdebugging xen_domctl_setdebugging_t; 370 DEFINE_XEN_GUEST_HANDLE(xen_domctl_setdebugging_t); 371 372 373 /* XEN_DOMCTL_irq_permission */ 374 struct xen_domctl_irq_permission { 375 uint8_t pirq; 376 uint8_t allow_access; /* flag to specify enable/disable of IRQ access */ 377 }; 378 typedef struct xen_domctl_irq_permission xen_domctl_irq_permission_t; 379 DEFINE_XEN_GUEST_HANDLE(xen_domctl_irq_permission_t); 380 381 382 /* XEN_DOMCTL_iomem_permission */ 383 struct xen_domctl_iomem_permission { 384 uint64_aligned_t first_mfn;/* first page (physical page number) in range */ 385 uint64_aligned_t nr_mfns; /* number of pages in range (>0) */ 386 uint8_t allow_access; /* allow (!0) or deny (0) access to range? */ 387 }; 388 typedef struct xen_domctl_iomem_permission xen_domctl_iomem_permission_t; 389 DEFINE_XEN_GUEST_HANDLE(xen_domctl_iomem_permission_t); 390 391 392 /* XEN_DOMCTL_ioport_permission */ 393 struct xen_domctl_ioport_permission { 394 uint32_t first_port; /* first port int range */ 395 uint32_t nr_ports; /* size of port range */ 396 uint8_t allow_access; /* allow or deny access to range? */ 397 }; 398 typedef struct xen_domctl_ioport_permission xen_domctl_ioport_permission_t; 399 DEFINE_XEN_GUEST_HANDLE(xen_domctl_ioport_permission_t); 400 401 402 /* XEN_DOMCTL_hypercall_init */ 403 struct xen_domctl_hypercall_init { 404 uint64_aligned_t gmfn; /* GMFN to be initialised */ 405 }; 406 typedef struct xen_domctl_hypercall_init xen_domctl_hypercall_init_t; 407 DEFINE_XEN_GUEST_HANDLE(xen_domctl_hypercall_init_t); 408 409 410 /* XEN_DOMCTL_settimeoffset */ 411 struct xen_domctl_settimeoffset { 412 int64_aligned_t time_offset_seconds; /* applied to domain wallclock time */ 413 }; 414 typedef struct xen_domctl_settimeoffset xen_domctl_settimeoffset_t; 415 DEFINE_XEN_GUEST_HANDLE(xen_domctl_settimeoffset_t); 416 417 /* XEN_DOMCTL_gethvmcontext */ 418 /* XEN_DOMCTL_sethvmcontext */ 419 typedef struct xen_domctl_hvmcontext { 420 uint32_t size; /* IN/OUT: size of buffer / bytes filled */ 421 XEN_GUEST_HANDLE_64(uint8) buffer; /* IN/OUT: data, or call 422 * gethvmcontext with NULL 423 * buffer to get size req'd */ 424 } xen_domctl_hvmcontext_t; 425 DEFINE_XEN_GUEST_HANDLE(xen_domctl_hvmcontext_t); 426 427 428 /* XEN_DOMCTL_set_address_size */ 429 /* XEN_DOMCTL_get_address_size */ 430 typedef struct xen_domctl_address_size { 431 uint32_t size; 432 } xen_domctl_address_size_t; 433 DEFINE_XEN_GUEST_HANDLE(xen_domctl_address_size_t); 434 435 436 /* XEN_DOMCTL_sendtrigger */ 437 #define XEN_DOMCTL_SENDTRIGGER_NMI 0 438 #define XEN_DOMCTL_SENDTRIGGER_RESET 1 439 #define XEN_DOMCTL_SENDTRIGGER_INIT 2 440 #define XEN_DOMCTL_SENDTRIGGER_POWER 3 441 #define XEN_DOMCTL_SENDTRIGGER_SLEEP 4 442 struct xen_domctl_sendtrigger { 443 uint32_t trigger; /* IN */ 444 uint32_t vcpu; /* IN */ 445 }; 446 typedef struct xen_domctl_sendtrigger xen_domctl_sendtrigger_t; 447 DEFINE_XEN_GUEST_HANDLE(xen_domctl_sendtrigger_t); 448 449 450 /* Assign a device to a guest. Sets up IOMMU structures. */ 451 /* XEN_DOMCTL_assign_device */ 452 /* XEN_DOMCTL_test_assign_device */ 453 /* 454 * XEN_DOMCTL_deassign_device: The behavior of this DOMCTL differs 455 * between the different type of device: 456 * - PCI device (XEN_DOMCTL_DEV_PCI) will be reassigned to DOM0 457 * - DT device (XEN_DOMCTL_DT_PCI) will left unassigned. DOM0 458 * will have to call XEN_DOMCTL_assign_device in order to use the 459 * device. 460 */ 461 #define XEN_DOMCTL_DEV_PCI 0 462 #define XEN_DOMCTL_DEV_DT 1 463 struct xen_domctl_assign_device { 464 uint32_t dev; /* XEN_DOMCTL_DEV_* */ 465 union { 466 struct { 467 uint32_t machine_sbdf; /* machine PCI ID of assigned device */ 468 } pci; 469 struct { 470 uint32_t size; /* Length of the path */ 471 XEN_GUEST_HANDLE_64(char) path; /* path to the device tree node */ 472 } dt; 473 } u; 474 /* IN */ 475 #define XEN_DOMCTL_DEV_RDM_RELAXED 1 476 uint32_t flag; /* flag of assigned device */ 477 }; 478 typedef struct xen_domctl_assign_device xen_domctl_assign_device_t; 479 DEFINE_XEN_GUEST_HANDLE(xen_domctl_assign_device_t); 480 481 /* Retrieve sibling devices infomation of machine_sbdf */ 482 /* XEN_DOMCTL_get_device_group */ 483 struct xen_domctl_get_device_group { 484 uint32_t machine_sbdf; /* IN */ 485 uint32_t max_sdevs; /* IN */ 486 uint32_t num_sdevs; /* OUT */ 487 XEN_GUEST_HANDLE_64(uint32) sdev_array; /* OUT */ 488 }; 489 typedef struct xen_domctl_get_device_group xen_domctl_get_device_group_t; 490 DEFINE_XEN_GUEST_HANDLE(xen_domctl_get_device_group_t); 491 492 /* Pass-through interrupts: bind real irq -> hvm devfn. */ 493 /* XEN_DOMCTL_bind_pt_irq */ 494 /* XEN_DOMCTL_unbind_pt_irq */ 495 typedef enum pt_irq_type_e { 496 PT_IRQ_TYPE_PCI, 497 PT_IRQ_TYPE_ISA, 498 PT_IRQ_TYPE_MSI, 499 PT_IRQ_TYPE_MSI_TRANSLATE, 500 PT_IRQ_TYPE_SPI, /* ARM: valid range 32-1019 */ 501 } pt_irq_type_t; 502 struct xen_domctl_bind_pt_irq { 503 uint32_t machine_irq; 504 pt_irq_type_t irq_type; 505 uint32_t hvm_domid; 506 507 union { 508 struct { 509 uint8_t isa_irq; 510 } isa; 511 struct { 512 uint8_t bus; 513 uint8_t device; 514 uint8_t intx; 515 } pci; 516 struct { 517 uint8_t gvec; 518 uint32_t gflags; 519 uint64_aligned_t gtable; 520 } msi; 521 struct { 522 uint16_t spi; 523 } spi; 524 } u; 525 }; 526 typedef struct xen_domctl_bind_pt_irq xen_domctl_bind_pt_irq_t; 527 DEFINE_XEN_GUEST_HANDLE(xen_domctl_bind_pt_irq_t); 528 529 530 /* Bind machine I/O address range -> HVM address range. */ 531 /* If this returns -E2BIG lower nr_mfns value. */ 532 /* XEN_DOMCTL_memory_mapping */ 533 #define DPCI_ADD_MAPPING 1 534 #define DPCI_REMOVE_MAPPING 0 535 struct xen_domctl_memory_mapping { 536 uint64_aligned_t first_gfn; /* first page (hvm guest phys page) in range */ 537 uint64_aligned_t first_mfn; /* first page (machine page) in range */ 538 uint64_aligned_t nr_mfns; /* number of pages in range (>0) */ 539 uint32_t add_mapping; /* add or remove mapping */ 540 uint32_t padding; /* padding for 64-bit aligned structure */ 541 }; 542 typedef struct xen_domctl_memory_mapping xen_domctl_memory_mapping_t; 543 DEFINE_XEN_GUEST_HANDLE(xen_domctl_memory_mapping_t); 544 545 546 /* Bind machine I/O port range -> HVM I/O port range. */ 547 /* XEN_DOMCTL_ioport_mapping */ 548 struct xen_domctl_ioport_mapping { 549 uint32_t first_gport; /* first guest IO port*/ 550 uint32_t first_mport; /* first machine IO port */ 551 uint32_t nr_ports; /* size of port range */ 552 uint32_t add_mapping; /* add or remove mapping */ 553 }; 554 typedef struct xen_domctl_ioport_mapping xen_domctl_ioport_mapping_t; 555 DEFINE_XEN_GUEST_HANDLE(xen_domctl_ioport_mapping_t); 556 557 558 /* 559 * Pin caching type of RAM space for x86 HVM domU. 560 */ 561 /* XEN_DOMCTL_pin_mem_cacheattr */ 562 /* Caching types: these happen to be the same as x86 MTRR/PAT type codes. */ 563 #define XEN_DOMCTL_MEM_CACHEATTR_UC 0 564 #define XEN_DOMCTL_MEM_CACHEATTR_WC 1 565 #define XEN_DOMCTL_MEM_CACHEATTR_WT 4 566 #define XEN_DOMCTL_MEM_CACHEATTR_WP 5 567 #define XEN_DOMCTL_MEM_CACHEATTR_WB 6 568 #define XEN_DOMCTL_MEM_CACHEATTR_UCM 7 569 #define XEN_DOMCTL_DELETE_MEM_CACHEATTR (~(uint32_t)0) 570 struct xen_domctl_pin_mem_cacheattr { 571 uint64_aligned_t start, end; 572 uint32_t type; /* XEN_DOMCTL_MEM_CACHEATTR_* */ 573 }; 574 typedef struct xen_domctl_pin_mem_cacheattr xen_domctl_pin_mem_cacheattr_t; 575 DEFINE_XEN_GUEST_HANDLE(xen_domctl_pin_mem_cacheattr_t); 576 577 578 /* XEN_DOMCTL_set_ext_vcpucontext */ 579 /* XEN_DOMCTL_get_ext_vcpucontext */ 580 struct xen_domctl_ext_vcpucontext { 581 /* IN: VCPU that this call applies to. */ 582 uint32_t vcpu; 583 /* 584 * SET: Size of struct (IN) 585 * GET: Size of struct (OUT, up to 128 bytes) 586 */ 587 uint32_t size; 588 #if defined(__i386__) || defined(__x86_64__) 589 /* SYSCALL from 32-bit mode and SYSENTER callback information. */ 590 /* NB. SYSCALL from 64-bit mode is contained in vcpu_guest_context_t */ 591 uint64_aligned_t syscall32_callback_eip; 592 uint64_aligned_t sysenter_callback_eip; 593 uint16_t syscall32_callback_cs; 594 uint16_t sysenter_callback_cs; 595 uint8_t syscall32_disables_events; 596 uint8_t sysenter_disables_events; 597 #if defined(__GNUC__) 598 union { 599 uint64_aligned_t mcg_cap; 600 struct hvm_vmce_vcpu vmce; 601 }; 602 #else 603 struct hvm_vmce_vcpu vmce; 604 #endif 605 #endif 606 }; 607 typedef struct xen_domctl_ext_vcpucontext xen_domctl_ext_vcpucontext_t; 608 DEFINE_XEN_GUEST_HANDLE(xen_domctl_ext_vcpucontext_t); 609 610 /* 611 * Set the target domain for a domain 612 */ 613 /* XEN_DOMCTL_set_target */ 614 struct xen_domctl_set_target { 615 domid_t target; 616 }; 617 typedef struct xen_domctl_set_target xen_domctl_set_target_t; 618 DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_target_t); 619 620 #if defined(__i386__) || defined(__x86_64__) 621 # define XEN_CPUID_INPUT_UNUSED 0xFFFFFFFF 622 /* XEN_DOMCTL_set_cpuid */ 623 struct xen_domctl_cpuid { 624 uint32_t input[2]; 625 uint32_t eax; 626 uint32_t ebx; 627 uint32_t ecx; 628 uint32_t edx; 629 }; 630 typedef struct xen_domctl_cpuid xen_domctl_cpuid_t; 631 DEFINE_XEN_GUEST_HANDLE(xen_domctl_cpuid_t); 632 #endif 633 634 /* 635 * Arranges that if the domain suspends (specifically, if it shuts 636 * down with code SHUTDOWN_suspend), this event channel will be 637 * notified. 638 * 639 * This is _instead of_ the usual notification to the global 640 * VIRQ_DOM_EXC. (In most systems that pirq is owned by xenstored.) 641 * 642 * Only one subscription per domain is possible. Last subscriber 643 * wins; others are silently displaced. 644 * 645 * NB that contrary to the rather general name, it only applies to 646 * domain shutdown with code suspend. Shutdown for other reasons 647 * (including crash), and domain death, are notified to VIRQ_DOM_EXC 648 * regardless. 649 */ 650 /* XEN_DOMCTL_subscribe */ 651 struct xen_domctl_subscribe { 652 uint32_t port; /* IN */ 653 }; 654 typedef struct xen_domctl_subscribe xen_domctl_subscribe_t; 655 DEFINE_XEN_GUEST_HANDLE(xen_domctl_subscribe_t); 656 657 /* 658 * Define the maximum machine address size which should be allocated 659 * to a guest. 660 */ 661 /* XEN_DOMCTL_set_machine_address_size */ 662 /* XEN_DOMCTL_get_machine_address_size */ 663 664 /* 665 * Do not inject spurious page faults into this domain. 666 */ 667 /* XEN_DOMCTL_suppress_spurious_page_faults */ 668 669 /* XEN_DOMCTL_debug_op */ 670 #define XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_OFF 0 671 #define XEN_DOMCTL_DEBUG_OP_SINGLE_STEP_ON 1 672 struct xen_domctl_debug_op { 673 uint32_t op; /* IN */ 674 uint32_t vcpu; /* IN */ 675 }; 676 typedef struct xen_domctl_debug_op xen_domctl_debug_op_t; 677 DEFINE_XEN_GUEST_HANDLE(xen_domctl_debug_op_t); 678 679 /* 680 * Request a particular record from the HVM context 681 */ 682 /* XEN_DOMCTL_gethvmcontext_partial */ 683 typedef struct xen_domctl_hvmcontext_partial { 684 uint32_t type; /* IN: Type of record required */ 685 uint32_t instance; /* IN: Instance of that type */ 686 XEN_GUEST_HANDLE_64(uint8) buffer; /* OUT: buffer to write record into */ 687 } xen_domctl_hvmcontext_partial_t; 688 DEFINE_XEN_GUEST_HANDLE(xen_domctl_hvmcontext_partial_t); 689 690 /* XEN_DOMCTL_disable_migrate */ 691 typedef struct xen_domctl_disable_migrate { 692 uint32_t disable; /* IN: 1: disable migration and restore */ 693 } xen_domctl_disable_migrate_t; 694 695 696 /* XEN_DOMCTL_gettscinfo */ 697 /* XEN_DOMCTL_settscinfo */ 698 typedef struct xen_domctl_tsc_info { 699 /* IN/OUT */ 700 uint32_t tsc_mode; 701 uint32_t gtsc_khz; 702 uint32_t incarnation; 703 uint32_t pad; 704 uint64_aligned_t elapsed_nsec; 705 } xen_domctl_tsc_info_t; 706 707 /* XEN_DOMCTL_gdbsx_guestmemio guest mem io */ 708 struct xen_domctl_gdbsx_memio { 709 /* IN */ 710 uint64_aligned_t pgd3val;/* optional: init_mm.pgd[3] value */ 711 uint64_aligned_t gva; /* guest virtual address */ 712 uint64_aligned_t uva; /* user buffer virtual address */ 713 uint32_t len; /* number of bytes to read/write */ 714 uint8_t gwr; /* 0 = read from guest. 1 = write to guest */ 715 /* OUT */ 716 uint32_t remain; /* bytes remaining to be copied */ 717 }; 718 719 /* XEN_DOMCTL_gdbsx_pausevcpu */ 720 /* XEN_DOMCTL_gdbsx_unpausevcpu */ 721 struct xen_domctl_gdbsx_pauseunp_vcpu { /* pause/unpause a vcpu */ 722 uint32_t vcpu; /* which vcpu */ 723 }; 724 725 /* XEN_DOMCTL_gdbsx_domstatus */ 726 struct xen_domctl_gdbsx_domstatus { 727 /* OUT */ 728 uint8_t paused; /* is the domain paused */ 729 uint32_t vcpu_id; /* any vcpu in an event? */ 730 uint32_t vcpu_ev; /* if yes, what event? */ 731 }; 732 733 /* 734 * VM event operations 735 */ 736 737 /* XEN_DOMCTL_vm_event_op */ 738 739 /* 740 * There are currently three rings available for VM events: 741 * sharing, monitor and paging. This hypercall allows one to 742 * control these rings (enable/disable), as well as to signal 743 * to the hypervisor to pull responses (resume) from the given 744 * ring. 745 */ 746 #define XEN_VM_EVENT_ENABLE 0 747 #define XEN_VM_EVENT_DISABLE 1 748 #define XEN_VM_EVENT_RESUME 2 749 750 /* 751 * Domain memory paging 752 * Page memory in and out. 753 * Domctl interface to set up and tear down the 754 * pager<->hypervisor interface. Use XENMEM_paging_op* 755 * to perform per-page operations. 756 * 757 * The XEN_VM_EVENT_PAGING_ENABLE domctl returns several 758 * non-standard error codes to indicate why paging could not be enabled: 759 * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest 760 * EMLINK - guest has iommu passthrough enabled 761 * EXDEV - guest has PoD enabled 762 * EBUSY - guest has or had paging enabled, ring buffer still active 763 */ 764 #define XEN_DOMCTL_VM_EVENT_OP_PAGING 1 765 766 /* 767 * Monitor helper. 768 * 769 * As with paging, use the domctl for teardown/setup of the 770 * helper<->hypervisor interface. 771 * 772 * The monitor interface can be used to register for various VM events. For 773 * example, there are HVM hypercalls to set the per-page access permissions 774 * of every page in a domain. When one of these permissions--independent, 775 * read, write, and execute--is violated, the VCPU is paused and a memory event 776 * is sent with what happened. The memory event handler can then resume the 777 * VCPU and redo the access with a XEN_VM_EVENT_RESUME option. 778 * 779 * See public/vm_event.h for the list of available events that can be 780 * subscribed to via the monitor interface. 781 * 782 * The XEN_VM_EVENT_MONITOR_* domctls returns 783 * non-standard error codes to indicate why access could not be enabled: 784 * ENODEV - host lacks HAP support (EPT/NPT) or HAP is disabled in guest 785 * EBUSY - guest has or had access enabled, ring buffer still active 786 * 787 */ 788 #define XEN_DOMCTL_VM_EVENT_OP_MONITOR 2 789 790 /* 791 * Sharing ENOMEM helper. 792 * 793 * As with paging, use the domctl for teardown/setup of the 794 * helper<->hypervisor interface. 795 * 796 * If setup, this ring is used to communicate failed allocations 797 * in the unshare path. XENMEM_sharing_op_resume is used to wake up 798 * vcpus that could not unshare. 799 * 800 * Note that shring can be turned on (as per the domctl below) 801 * *without* this ring being setup. 802 */ 803 #define XEN_DOMCTL_VM_EVENT_OP_SHARING 3 804 805 /* Use for teardown/setup of helper<->hypervisor interface for paging, 806 * access and sharing.*/ 807 struct xen_domctl_vm_event_op { 808 uint32_t op; /* XEN_VM_EVENT_* */ 809 uint32_t mode; /* XEN_DOMCTL_VM_EVENT_OP_* */ 810 811 uint32_t port; /* OUT: event channel for ring */ 812 }; 813 typedef struct xen_domctl_vm_event_op xen_domctl_vm_event_op_t; 814 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vm_event_op_t); 815 816 /* 817 * Memory sharing operations 818 */ 819 /* XEN_DOMCTL_mem_sharing_op. 820 * The CONTROL sub-domctl is used for bringup/teardown. */ 821 #define XEN_DOMCTL_MEM_SHARING_CONTROL 0 822 823 struct xen_domctl_mem_sharing_op { 824 uint8_t op; /* XEN_DOMCTL_MEM_SHARING_* */ 825 826 union { 827 uint8_t enable; /* CONTROL */ 828 } u; 829 }; 830 typedef struct xen_domctl_mem_sharing_op xen_domctl_mem_sharing_op_t; 831 DEFINE_XEN_GUEST_HANDLE(xen_domctl_mem_sharing_op_t); 832 833 struct xen_domctl_audit_p2m { 834 /* OUT error counts */ 835 uint64_t orphans; 836 uint64_t m2p_bad; 837 uint64_t p2m_bad; 838 }; 839 typedef struct xen_domctl_audit_p2m xen_domctl_audit_p2m_t; 840 DEFINE_XEN_GUEST_HANDLE(xen_domctl_audit_p2m_t); 841 842 struct xen_domctl_set_virq_handler { 843 uint32_t virq; /* IN */ 844 }; 845 typedef struct xen_domctl_set_virq_handler xen_domctl_set_virq_handler_t; 846 DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_virq_handler_t); 847 848 #if defined(__i386__) || defined(__x86_64__) 849 /* XEN_DOMCTL_setvcpuextstate */ 850 /* XEN_DOMCTL_getvcpuextstate */ 851 struct xen_domctl_vcpuextstate { 852 /* IN: VCPU that this call applies to. */ 853 uint32_t vcpu; 854 /* 855 * SET: Ignored. 856 * GET: xfeature support mask of struct (IN/OUT) 857 * xfeature mask is served as identifications of the saving format 858 * so that compatible CPUs can have a check on format to decide 859 * whether it can restore. 860 */ 861 uint64_aligned_t xfeature_mask; 862 /* 863 * SET: Size of struct (IN) 864 * GET: Size of struct (IN/OUT) 865 */ 866 uint64_aligned_t size; 867 XEN_GUEST_HANDLE_64(uint64) buffer; 868 }; 869 typedef struct xen_domctl_vcpuextstate xen_domctl_vcpuextstate_t; 870 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpuextstate_t); 871 #endif 872 873 /* XEN_DOMCTL_set_access_required: sets whether a memory event listener 874 * must be present to handle page access events: if false, the page 875 * access will revert to full permissions if no one is listening; 876 * */ 877 struct xen_domctl_set_access_required { 878 uint8_t access_required; 879 }; 880 typedef struct xen_domctl_set_access_required xen_domctl_set_access_required_t; 881 DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_access_required_t); 882 883 struct xen_domctl_set_broken_page_p2m { 884 uint64_aligned_t pfn; 885 }; 886 typedef struct xen_domctl_set_broken_page_p2m xen_domctl_set_broken_page_p2m_t; 887 DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_broken_page_p2m_t); 888 889 /* 890 * XEN_DOMCTL_set_max_evtchn: sets the maximum event channel port 891 * number the guest may use. Use this limit the amount of resources 892 * (global mapping space, xenheap) a guest may use for event channels. 893 */ 894 struct xen_domctl_set_max_evtchn { 895 uint32_t max_port; 896 }; 897 typedef struct xen_domctl_set_max_evtchn xen_domctl_set_max_evtchn_t; 898 DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_max_evtchn_t); 899 900 /* 901 * ARM: Clean and invalidate caches associated with given region of 902 * guest memory. 903 */ 904 struct xen_domctl_cacheflush { 905 /* IN: page range to flush. */ 906 xen_pfn_t start_pfn, nr_pfns; 907 }; 908 typedef struct xen_domctl_cacheflush xen_domctl_cacheflush_t; 909 DEFINE_XEN_GUEST_HANDLE(xen_domctl_cacheflush_t); 910 911 #if defined(__i386__) || defined(__x86_64__) 912 struct xen_domctl_vcpu_msr { 913 uint32_t index; 914 uint32_t reserved; 915 uint64_aligned_t value; 916 }; 917 typedef struct xen_domctl_vcpu_msr xen_domctl_vcpu_msr_t; 918 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpu_msr_t); 919 920 /* 921 * XEN_DOMCTL_set_vcpu_msrs / XEN_DOMCTL_get_vcpu_msrs. 922 * 923 * Input: 924 * - A NULL 'msrs' guest handle is a request for the maximum 'msr_count'. 925 * - Otherwise, 'msr_count' is the number of entries in 'msrs'. 926 * 927 * Output for get: 928 * - If 'msr_count' is less than the number Xen needs to write, -ENOBUFS shall 929 * be returned and 'msr_count' updated to reflect the intended number. 930 * - On success, 'msr_count' shall indicate the number of MSRs written, which 931 * may be less than the maximum if some are not currently used by the vcpu. 932 * 933 * Output for set: 934 * - If Xen encounters an error with a specific MSR, -EINVAL shall be returned 935 * and 'msr_count' shall be set to the offending index, to aid debugging. 936 */ 937 struct xen_domctl_vcpu_msrs { 938 uint32_t vcpu; /* IN */ 939 uint32_t msr_count; /* IN/OUT */ 940 XEN_GUEST_HANDLE_64(xen_domctl_vcpu_msr_t) msrs; /* IN/OUT */ 941 }; 942 typedef struct xen_domctl_vcpu_msrs xen_domctl_vcpu_msrs_t; 943 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vcpu_msrs_t); 944 #endif 945 946 /* XEN_DOMCTL_setvnumainfo: specifies a virtual NUMA topology for the guest */ 947 struct xen_domctl_vnuma { 948 /* IN: number of vNUMA nodes to setup. Shall be greater than 0 */ 949 uint32_t nr_vnodes; 950 /* IN: number of memory ranges to setup */ 951 uint32_t nr_vmemranges; 952 /* 953 * IN: number of vCPUs of the domain (used as size of the vcpu_to_vnode 954 * array declared below). Shall be equal to the domain's max_vcpus. 955 */ 956 uint32_t nr_vcpus; 957 uint32_t pad; /* must be zero */ 958 959 /* 960 * IN: array for specifying the distances of the vNUMA nodes 961 * between each others. Shall have nr_vnodes*nr_vnodes elements. 962 */ 963 XEN_GUEST_HANDLE_64(uint) vdistance; 964 /* 965 * IN: array for specifying to what vNUMA node each vCPU belongs. 966 * Shall have nr_vcpus elements. 967 */ 968 XEN_GUEST_HANDLE_64(uint) vcpu_to_vnode; 969 /* 970 * IN: array for specifying on what physical NUMA node each vNUMA 971 * node is placed. Shall have nr_vnodes elements. 972 */ 973 XEN_GUEST_HANDLE_64(uint) vnode_to_pnode; 974 /* 975 * IN: array for specifying the memory ranges. Shall have 976 * nr_vmemranges elements. 977 */ 978 XEN_GUEST_HANDLE_64(xen_vmemrange_t) vmemrange; 979 }; 980 typedef struct xen_domctl_vnuma xen_domctl_vnuma_t; 981 DEFINE_XEN_GUEST_HANDLE(xen_domctl_vnuma_t); 982 983 struct xen_domctl_psr_cmt_op { 984 #define XEN_DOMCTL_PSR_CMT_OP_DETACH 0 985 #define XEN_DOMCTL_PSR_CMT_OP_ATTACH 1 986 #define XEN_DOMCTL_PSR_CMT_OP_QUERY_RMID 2 987 uint32_t cmd; 988 uint32_t data; 989 }; 990 typedef struct xen_domctl_psr_cmt_op xen_domctl_psr_cmt_op_t; 991 DEFINE_XEN_GUEST_HANDLE(xen_domctl_psr_cmt_op_t); 992 993 /* XEN_DOMCTL_MONITOR_* 994 * 995 * Enable/disable monitoring various VM events. 996 * This domctl configures what events will be reported to helper apps 997 * via the ring buffer "MONITOR". The ring has to be first enabled 998 * with the domctl XEN_DOMCTL_VM_EVENT_OP_MONITOR. 999 * 1000 * GET_CAPABILITIES can be used to determine which of these features is 1001 * available on a given platform. 1002 * 1003 * NOTICE: mem_access events are also delivered via the "MONITOR" ring buffer; 1004 * however, enabling/disabling those events is performed with the use of 1005 * memory_op hypercalls! 1006 */ 1007 #define XEN_DOMCTL_MONITOR_OP_ENABLE 0 1008 #define XEN_DOMCTL_MONITOR_OP_DISABLE 1 1009 #define XEN_DOMCTL_MONITOR_OP_GET_CAPABILITIES 2 1010 1011 #define XEN_DOMCTL_MONITOR_EVENT_WRITE_CTRLREG 0 1012 #define XEN_DOMCTL_MONITOR_EVENT_MOV_TO_MSR 1 1013 #define XEN_DOMCTL_MONITOR_EVENT_SINGLESTEP 2 1014 #define XEN_DOMCTL_MONITOR_EVENT_SOFTWARE_BREAKPOINT 3 1015 #define XEN_DOMCTL_MONITOR_EVENT_GUEST_REQUEST 4 1016 1017 struct xen_domctl_monitor_op { 1018 uint32_t op; /* XEN_DOMCTL_MONITOR_OP_* */ 1019 1020 /* 1021 * When used with ENABLE/DISABLE this has to be set to 1022 * the requested XEN_DOMCTL_MONITOR_EVENT_* value. 1023 * With GET_CAPABILITIES this field returns a bitmap of 1024 * events supported by the platform, in the format 1025 * (1 << XEN_DOMCTL_MONITOR_EVENT_*). 1026 */ 1027 uint32_t event; 1028 1029 /* 1030 * Further options when issuing XEN_DOMCTL_MONITOR_OP_ENABLE. 1031 */ 1032 union { 1033 struct { 1034 /* Which control register */ 1035 uint8_t index; 1036 /* Pause vCPU until response */ 1037 uint8_t sync; 1038 /* Send event only on a change of value */ 1039 uint8_t onchangeonly; 1040 } mov_to_cr; 1041 1042 struct { 1043 /* Enable the capture of an extended set of MSRs */ 1044 uint8_t extended_capture; 1045 } mov_to_msr; 1046 1047 struct { 1048 /* Pause vCPU until response */ 1049 uint8_t sync; 1050 } guest_request; 1051 } u; 1052 }; 1053 typedef struct xen_domctl_monitor_op xen_domctl_monitor_op_t; 1054 DEFINE_XEN_GUEST_HANDLE(xen_domctl_monitor_op_t); 1055 1056 struct xen_domctl_psr_cat_op { 1057 #define XEN_DOMCTL_PSR_CAT_OP_SET_L3_CBM 0 1058 #define XEN_DOMCTL_PSR_CAT_OP_GET_L3_CBM 1 1059 uint32_t cmd; /* IN: XEN_DOMCTL_PSR_CAT_OP_* */ 1060 uint32_t target; /* IN */ 1061 uint64_t data; /* IN/OUT */ 1062 }; 1063 typedef struct xen_domctl_psr_cat_op xen_domctl_psr_cat_op_t; 1064 DEFINE_XEN_GUEST_HANDLE(xen_domctl_psr_cat_op_t); 1065 1066 struct xen_domctl { 1067 uint32_t cmd; 1068 #define XEN_DOMCTL_createdomain 1 1069 #define XEN_DOMCTL_destroydomain 2 1070 #define XEN_DOMCTL_pausedomain 3 1071 #define XEN_DOMCTL_unpausedomain 4 1072 #define XEN_DOMCTL_getdomaininfo 5 1073 #define XEN_DOMCTL_getmemlist 6 1074 /* #define XEN_DOMCTL_getpageframeinfo 7 Obsolete - use getpageframeinfo3 */ 1075 /* #define XEN_DOMCTL_getpageframeinfo2 8 Obsolete - use getpageframeinfo3 */ 1076 #define XEN_DOMCTL_setvcpuaffinity 9 1077 #define XEN_DOMCTL_shadow_op 10 1078 #define XEN_DOMCTL_max_mem 11 1079 #define XEN_DOMCTL_setvcpucontext 12 1080 #define XEN_DOMCTL_getvcpucontext 13 1081 #define XEN_DOMCTL_getvcpuinfo 14 1082 #define XEN_DOMCTL_max_vcpus 15 1083 #define XEN_DOMCTL_scheduler_op 16 1084 #define XEN_DOMCTL_setdomainhandle 17 1085 #define XEN_DOMCTL_setdebugging 18 1086 #define XEN_DOMCTL_irq_permission 19 1087 #define XEN_DOMCTL_iomem_permission 20 1088 #define XEN_DOMCTL_ioport_permission 21 1089 #define XEN_DOMCTL_hypercall_init 22 1090 #define XEN_DOMCTL_arch_setup 23 /* Obsolete IA64 only */ 1091 #define XEN_DOMCTL_settimeoffset 24 1092 #define XEN_DOMCTL_getvcpuaffinity 25 1093 #define XEN_DOMCTL_real_mode_area 26 /* Obsolete PPC only */ 1094 #define XEN_DOMCTL_resumedomain 27 1095 #define XEN_DOMCTL_sendtrigger 28 1096 #define XEN_DOMCTL_subscribe 29 1097 #define XEN_DOMCTL_gethvmcontext 33 1098 #define XEN_DOMCTL_sethvmcontext 34 1099 #define XEN_DOMCTL_set_address_size 35 1100 #define XEN_DOMCTL_get_address_size 36 1101 #define XEN_DOMCTL_assign_device 37 1102 #define XEN_DOMCTL_bind_pt_irq 38 1103 #define XEN_DOMCTL_memory_mapping 39 1104 #define XEN_DOMCTL_ioport_mapping 40 1105 #define XEN_DOMCTL_pin_mem_cacheattr 41 1106 #define XEN_DOMCTL_set_ext_vcpucontext 42 1107 #define XEN_DOMCTL_get_ext_vcpucontext 43 1108 #define XEN_DOMCTL_set_opt_feature 44 /* Obsolete IA64 only */ 1109 #define XEN_DOMCTL_test_assign_device 45 1110 #define XEN_DOMCTL_set_target 46 1111 #define XEN_DOMCTL_deassign_device 47 1112 #define XEN_DOMCTL_unbind_pt_irq 48 1113 #define XEN_DOMCTL_set_cpuid 49 1114 #define XEN_DOMCTL_get_device_group 50 1115 #define XEN_DOMCTL_set_machine_address_size 51 1116 #define XEN_DOMCTL_get_machine_address_size 52 1117 #define XEN_DOMCTL_suppress_spurious_page_faults 53 1118 #define XEN_DOMCTL_debug_op 54 1119 #define XEN_DOMCTL_gethvmcontext_partial 55 1120 #define XEN_DOMCTL_vm_event_op 56 1121 #define XEN_DOMCTL_mem_sharing_op 57 1122 #define XEN_DOMCTL_disable_migrate 58 1123 #define XEN_DOMCTL_gettscinfo 59 1124 #define XEN_DOMCTL_settscinfo 60 1125 #define XEN_DOMCTL_getpageframeinfo3 61 1126 #define XEN_DOMCTL_setvcpuextstate 62 1127 #define XEN_DOMCTL_getvcpuextstate 63 1128 #define XEN_DOMCTL_set_access_required 64 1129 #define XEN_DOMCTL_audit_p2m 65 1130 #define XEN_DOMCTL_set_virq_handler 66 1131 #define XEN_DOMCTL_set_broken_page_p2m 67 1132 #define XEN_DOMCTL_setnodeaffinity 68 1133 #define XEN_DOMCTL_getnodeaffinity 69 1134 #define XEN_DOMCTL_set_max_evtchn 70 1135 #define XEN_DOMCTL_cacheflush 71 1136 #define XEN_DOMCTL_get_vcpu_msrs 72 1137 #define XEN_DOMCTL_set_vcpu_msrs 73 1138 #define XEN_DOMCTL_setvnumainfo 74 1139 #define XEN_DOMCTL_psr_cmt_op 75 1140 #define XEN_DOMCTL_monitor_op 77 1141 #define XEN_DOMCTL_psr_cat_op 78 1142 #define XEN_DOMCTL_gdbsx_guestmemio 1000 1143 #define XEN_DOMCTL_gdbsx_pausevcpu 1001 1144 #define XEN_DOMCTL_gdbsx_unpausevcpu 1002 1145 #define XEN_DOMCTL_gdbsx_domstatus 1003 1146 uint32_t interface_version; /* XEN_DOMCTL_INTERFACE_VERSION */ 1147 domid_t domain; 1148 union { 1149 struct xen_domctl_createdomain createdomain; 1150 struct xen_domctl_getdomaininfo getdomaininfo; 1151 struct xen_domctl_getmemlist getmemlist; 1152 struct xen_domctl_getpageframeinfo3 getpageframeinfo3; 1153 struct xen_domctl_nodeaffinity nodeaffinity; 1154 struct xen_domctl_vcpuaffinity vcpuaffinity; 1155 struct xen_domctl_shadow_op shadow_op; 1156 struct xen_domctl_max_mem max_mem; 1157 struct xen_domctl_vcpucontext vcpucontext; 1158 struct xen_domctl_getvcpuinfo getvcpuinfo; 1159 struct xen_domctl_max_vcpus max_vcpus; 1160 struct xen_domctl_scheduler_op scheduler_op; 1161 struct xen_domctl_setdomainhandle setdomainhandle; 1162 struct xen_domctl_setdebugging setdebugging; 1163 struct xen_domctl_irq_permission irq_permission; 1164 struct xen_domctl_iomem_permission iomem_permission; 1165 struct xen_domctl_ioport_permission ioport_permission; 1166 struct xen_domctl_hypercall_init hypercall_init; 1167 struct xen_domctl_settimeoffset settimeoffset; 1168 struct xen_domctl_disable_migrate disable_migrate; 1169 struct xen_domctl_tsc_info tsc_info; 1170 struct xen_domctl_hvmcontext hvmcontext; 1171 struct xen_domctl_hvmcontext_partial hvmcontext_partial; 1172 struct xen_domctl_address_size address_size; 1173 struct xen_domctl_sendtrigger sendtrigger; 1174 struct xen_domctl_get_device_group get_device_group; 1175 struct xen_domctl_assign_device assign_device; 1176 struct xen_domctl_bind_pt_irq bind_pt_irq; 1177 struct xen_domctl_memory_mapping memory_mapping; 1178 struct xen_domctl_ioport_mapping ioport_mapping; 1179 struct xen_domctl_pin_mem_cacheattr pin_mem_cacheattr; 1180 struct xen_domctl_ext_vcpucontext ext_vcpucontext; 1181 struct xen_domctl_set_target set_target; 1182 struct xen_domctl_subscribe subscribe; 1183 struct xen_domctl_debug_op debug_op; 1184 struct xen_domctl_vm_event_op vm_event_op; 1185 struct xen_domctl_mem_sharing_op mem_sharing_op; 1186 #if defined(__i386__) || defined(__x86_64__) 1187 struct xen_domctl_cpuid cpuid; 1188 struct xen_domctl_vcpuextstate vcpuextstate; 1189 struct xen_domctl_vcpu_msrs vcpu_msrs; 1190 #endif 1191 struct xen_domctl_set_access_required access_required; 1192 struct xen_domctl_audit_p2m audit_p2m; 1193 struct xen_domctl_set_virq_handler set_virq_handler; 1194 struct xen_domctl_set_max_evtchn set_max_evtchn; 1195 struct xen_domctl_gdbsx_memio gdbsx_guest_memio; 1196 struct xen_domctl_set_broken_page_p2m set_broken_page_p2m; 1197 struct xen_domctl_cacheflush cacheflush; 1198 struct xen_domctl_gdbsx_pauseunp_vcpu gdbsx_pauseunp_vcpu; 1199 struct xen_domctl_gdbsx_domstatus gdbsx_domstatus; 1200 struct xen_domctl_vnuma vnuma; 1201 struct xen_domctl_psr_cmt_op psr_cmt_op; 1202 struct xen_domctl_monitor_op monitor_op; 1203 struct xen_domctl_psr_cat_op psr_cat_op; 1204 uint8_t pad[128]; 1205 } u; 1206 }; 1207 typedef struct xen_domctl xen_domctl_t; 1208 DEFINE_XEN_GUEST_HANDLE(xen_domctl_t); 1209 1210 #endif /* __XEN_PUBLIC_DOMCTL_H__ */ 1211 1212 /* 1213 * Local variables: 1214 * mode: C 1215 * c-file-style: "BSD" 1216 * c-basic-offset: 4 1217 * tab-width: 4 1218 * indent-tabs-mode: nil 1219 * End: 1220 */ 1221