![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to xen.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / xen / public|
Return to xen.h CVS log | Up to [GnuMach] / Gnu-Mach / xen / public |
1.1 ! root 1: /****************************************************************************** ! 2: * xen.h ! 3: * ! 4: * Guest OS interface to Xen. ! 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) 2004, K A Fraser ! 25: */ ! 26: ! 27: #ifndef __XEN_PUBLIC_XEN_H__ ! 28: #define __XEN_PUBLIC_XEN_H__ ! 29: ! 30: #include <sys/types.h> ! 31: ! 32: #include "xen-compat.h" ! 33: ! 34: #if defined(__i386__) || defined(__x86_64__) ! 35: #include "arch-x86/xen.h" ! 36: #elif defined(__ia64__) ! 37: #include "arch-ia64.h" ! 38: #else ! 39: #error "Unsupported architecture" ! 40: #endif ! 41: ! 42: #ifndef __ASSEMBLY__ ! 43: /* Guest handles for primitive C types. */ ! 44: DEFINE_XEN_GUEST_HANDLE(char); ! 45: __DEFINE_XEN_GUEST_HANDLE(uchar, unsigned char); ! 46: DEFINE_XEN_GUEST_HANDLE(int); ! 47: __DEFINE_XEN_GUEST_HANDLE(uint, unsigned int); ! 48: DEFINE_XEN_GUEST_HANDLE(long); ! 49: __DEFINE_XEN_GUEST_HANDLE(ulong, unsigned long); ! 50: DEFINE_XEN_GUEST_HANDLE(void); ! 51: ! 52: DEFINE_XEN_GUEST_HANDLE(xen_pfn_t); ! 53: #endif ! 54: ! 55: /* ! 56: * HYPERCALLS ! 57: */ ! 58: ! 59: #define __HYPERVISOR_set_trap_table 0 ! 60: #define __HYPERVISOR_mmu_update 1 ! 61: #define __HYPERVISOR_set_gdt 2 ! 62: #define __HYPERVISOR_stack_switch 3 ! 63: #define __HYPERVISOR_set_callbacks 4 ! 64: #define __HYPERVISOR_fpu_taskswitch 5 ! 65: #define __HYPERVISOR_sched_op_compat 6 /* compat since 0x00030101 */ ! 66: #define __HYPERVISOR_platform_op 7 ! 67: #define __HYPERVISOR_set_debugreg 8 ! 68: #define __HYPERVISOR_get_debugreg 9 ! 69: #define __HYPERVISOR_update_descriptor 10 ! 70: #define __HYPERVISOR_memory_op 12 ! 71: #define __HYPERVISOR_multicall 13 ! 72: #define __HYPERVISOR_update_va_mapping 14 ! 73: #define __HYPERVISOR_set_timer_op 15 ! 74: #define __HYPERVISOR_event_channel_op_compat 16 /* compat since 0x00030202 */ ! 75: #define __HYPERVISOR_xen_version 17 ! 76: #define __HYPERVISOR_console_io 18 ! 77: #define __HYPERVISOR_physdev_op_compat 19 /* compat since 0x00030202 */ ! 78: #define __HYPERVISOR_grant_table_op 20 ! 79: #define __HYPERVISOR_vm_assist 21 ! 80: #define __HYPERVISOR_update_va_mapping_otherdomain 22 ! 81: #define __HYPERVISOR_iret 23 /* x86 only */ ! 82: #define __HYPERVISOR_vcpu_op 24 ! 83: #define __HYPERVISOR_set_segment_base 25 /* x86/64 only */ ! 84: #define __HYPERVISOR_mmuext_op 26 ! 85: #define __HYPERVISOR_xsm_op 27 ! 86: #define __HYPERVISOR_nmi_op 28 ! 87: #define __HYPERVISOR_sched_op 29 ! 88: #define __HYPERVISOR_callback_op 30 ! 89: #define __HYPERVISOR_xenoprof_op 31 ! 90: #define __HYPERVISOR_event_channel_op 32 ! 91: #define __HYPERVISOR_physdev_op 33 ! 92: #define __HYPERVISOR_hvm_op 34 ! 93: #define __HYPERVISOR_sysctl 35 ! 94: #define __HYPERVISOR_domctl 36 ! 95: #define __HYPERVISOR_kexec_op 37 ! 96: ! 97: /* Architecture-specific hypercall definitions. */ ! 98: #define __HYPERVISOR_arch_0 48 ! 99: #define __HYPERVISOR_arch_1 49 ! 100: #define __HYPERVISOR_arch_2 50 ! 101: #define __HYPERVISOR_arch_3 51 ! 102: #define __HYPERVISOR_arch_4 52 ! 103: #define __HYPERVISOR_arch_5 53 ! 104: #define __HYPERVISOR_arch_6 54 ! 105: #define __HYPERVISOR_arch_7 55 ! 106: ! 107: /* ! 108: * HYPERCALL COMPATIBILITY. ! 109: */ ! 110: ! 111: /* New sched_op hypercall introduced in 0x00030101. */ ! 112: #if __XEN_INTERFACE_VERSION__ < 0x00030101 ! 113: #undef __HYPERVISOR_sched_op ! 114: #define __HYPERVISOR_sched_op __HYPERVISOR_sched_op_compat ! 115: #endif ! 116: ! 117: /* New event-channel and physdev hypercalls introduced in 0x00030202. */ ! 118: #if __XEN_INTERFACE_VERSION__ < 0x00030202 ! 119: #undef __HYPERVISOR_event_channel_op ! 120: #define __HYPERVISOR_event_channel_op __HYPERVISOR_event_channel_op_compat ! 121: #undef __HYPERVISOR_physdev_op ! 122: #define __HYPERVISOR_physdev_op __HYPERVISOR_physdev_op_compat ! 123: #endif ! 124: ! 125: /* New platform_op hypercall introduced in 0x00030204. */ ! 126: #if __XEN_INTERFACE_VERSION__ < 0x00030204 ! 127: #define __HYPERVISOR_dom0_op __HYPERVISOR_platform_op ! 128: #endif ! 129: ! 130: /* ! 131: * VIRTUAL INTERRUPTS ! 132: * ! 133: * Virtual interrupts that a guest OS may receive from Xen. ! 134: * ! 135: * In the side comments, 'V.' denotes a per-VCPU VIRQ while 'G.' denotes a ! 136: * global VIRQ. The former can be bound once per VCPU and cannot be re-bound. ! 137: * The latter can be allocated only once per guest: they must initially be ! 138: * allocated to VCPU0 but can subsequently be re-bound. ! 139: */ ! 140: #define VIRQ_TIMER 0 /* V. Timebase update, and/or requested timeout. */ ! 141: #define VIRQ_DEBUG 1 /* V. Request guest to dump debug info. */ ! 142: #define VIRQ_CONSOLE 2 /* G. (DOM0) Bytes received on emergency console. */ ! 143: #define VIRQ_DOM_EXC 3 /* G. (DOM0) Exceptional event for some domain. */ ! 144: #define VIRQ_TBUF 4 /* G. (DOM0) Trace buffer has records available. */ ! 145: #define VIRQ_DEBUGGER 6 /* G. (DOM0) A domain has paused for debugging. */ ! 146: #define VIRQ_XENOPROF 7 /* V. XenOprofile interrupt: new sample available */ ! 147: #define VIRQ_CON_RING 8 /* G. (DOM0) Bytes received on console */ ! 148: ! 149: /* Architecture-specific VIRQ definitions. */ ! 150: #define VIRQ_ARCH_0 16 ! 151: #define VIRQ_ARCH_1 17 ! 152: #define VIRQ_ARCH_2 18 ! 153: #define VIRQ_ARCH_3 19 ! 154: #define VIRQ_ARCH_4 20 ! 155: #define VIRQ_ARCH_5 21 ! 156: #define VIRQ_ARCH_6 22 ! 157: #define VIRQ_ARCH_7 23 ! 158: ! 159: #define NR_VIRQS 24 ! 160: ! 161: /* ! 162: * MMU-UPDATE REQUESTS ! 163: * ! 164: * HYPERVISOR_mmu_update() accepts a list of (ptr, val) pairs. ! 165: * A foreigndom (FD) can be specified (or DOMID_SELF for none). ! 166: * Where the FD has some effect, it is described below. ! 167: * ptr[1:0] specifies the appropriate MMU_* command. ! 168: * ! 169: * ptr[1:0] == MMU_NORMAL_PT_UPDATE: ! 170: * Updates an entry in a page table. If updating an L1 table, and the new ! 171: * table entry is valid/present, the mapped frame must belong to the FD, if ! 172: * an FD has been specified. If attempting to map an I/O page then the ! 173: * caller assumes the privilege of the FD. ! 174: * FD == DOMID_IO: Permit /only/ I/O mappings, at the priv level of the caller. ! 175: * FD == DOMID_XEN: Map restricted areas of Xen's heap space. ! 176: * ptr[:2] -- Machine address of the page-table entry to modify. ! 177: * val -- Value to write. ! 178: * ! 179: * ptr[1:0] == MMU_MACHPHYS_UPDATE: ! 180: * Updates an entry in the machine->pseudo-physical mapping table. ! 181: * ptr[:2] -- Machine address within the frame whose mapping to modify. ! 182: * The frame must belong to the FD, if one is specified. ! 183: * val -- Value to write into the mapping entry. ! 184: * ! 185: * ptr[1:0] == MMU_PT_UPDATE_PRESERVE_AD: ! 186: * As MMU_NORMAL_PT_UPDATE above, but A/D bits currently in the PTE are ORed ! 187: * with those in @val. ! 188: */ ! 189: #define MMU_NORMAL_PT_UPDATE 0 /* checked '*ptr = val'. ptr is MA. */ ! 190: #define MMU_MACHPHYS_UPDATE 1 /* ptr = MA of frame to modify entry for */ ! 191: #define MMU_PT_UPDATE_PRESERVE_AD 2 /* atomically: *ptr = val | (*ptr&(A|D)) */ ! 192: ! 193: /* ! 194: * MMU EXTENDED OPERATIONS ! 195: * ! 196: * HYPERVISOR_mmuext_op() accepts a list of mmuext_op structures. ! 197: * A foreigndom (FD) can be specified (or DOMID_SELF for none). ! 198: * Where the FD has some effect, it is described below. ! 199: * ! 200: * cmd: MMUEXT_(UN)PIN_*_TABLE ! 201: * mfn: Machine frame number to be (un)pinned as a p.t. page. ! 202: * The frame must belong to the FD, if one is specified. ! 203: * ! 204: * cmd: MMUEXT_NEW_BASEPTR ! 205: * mfn: Machine frame number of new page-table base to install in MMU. ! 206: * ! 207: * cmd: MMUEXT_NEW_USER_BASEPTR [x86/64 only] ! 208: * mfn: Machine frame number of new page-table base to install in MMU ! 209: * when in user space. ! 210: * ! 211: * cmd: MMUEXT_TLB_FLUSH_LOCAL ! 212: * No additional arguments. Flushes local TLB. ! 213: * ! 214: * cmd: MMUEXT_INVLPG_LOCAL ! 215: * linear_addr: Linear address to be flushed from the local TLB. ! 216: * ! 217: * cmd: MMUEXT_TLB_FLUSH_MULTI ! 218: * vcpumask: Pointer to bitmap of VCPUs to be flushed. ! 219: * ! 220: * cmd: MMUEXT_INVLPG_MULTI ! 221: * linear_addr: Linear address to be flushed. ! 222: * vcpumask: Pointer to bitmap of VCPUs to be flushed. ! 223: * ! 224: * cmd: MMUEXT_TLB_FLUSH_ALL ! 225: * No additional arguments. Flushes all VCPUs' TLBs. ! 226: * ! 227: * cmd: MMUEXT_INVLPG_ALL ! 228: * linear_addr: Linear address to be flushed from all VCPUs' TLBs. ! 229: * ! 230: * cmd: MMUEXT_FLUSH_CACHE ! 231: * No additional arguments. Writes back and flushes cache contents. ! 232: * ! 233: * cmd: MMUEXT_SET_LDT ! 234: * linear_addr: Linear address of LDT base (NB. must be page-aligned). ! 235: * nr_ents: Number of entries in LDT. ! 236: * ! 237: * cmd: MMUEXT_CLEAR_PAGE ! 238: * mfn: Machine frame number to be cleared. ! 239: * ! 240: * cmd: MMUEXT_COPY_PAGE ! 241: * mfn: Machine frame number of the destination page. ! 242: * src_mfn: Machine frame number of the source page. ! 243: */ ! 244: #define MMUEXT_PIN_L1_TABLE 0 ! 245: #define MMUEXT_PIN_L2_TABLE 1 ! 246: #define MMUEXT_PIN_L3_TABLE 2 ! 247: #define MMUEXT_PIN_L4_TABLE 3 ! 248: #define MMUEXT_UNPIN_TABLE 4 ! 249: #define MMUEXT_NEW_BASEPTR 5 ! 250: #define MMUEXT_TLB_FLUSH_LOCAL 6 ! 251: #define MMUEXT_INVLPG_LOCAL 7 ! 252: #define MMUEXT_TLB_FLUSH_MULTI 8 ! 253: #define MMUEXT_INVLPG_MULTI 9 ! 254: #define MMUEXT_TLB_FLUSH_ALL 10 ! 255: #define MMUEXT_INVLPG_ALL 11 ! 256: #define MMUEXT_FLUSH_CACHE 12 ! 257: #define MMUEXT_SET_LDT 13 ! 258: #define MMUEXT_NEW_USER_BASEPTR 15 ! 259: #define MMUEXT_CLEAR_PAGE 16 ! 260: #define MMUEXT_COPY_PAGE 17 ! 261: ! 262: #ifndef __ASSEMBLY__ ! 263: struct mmuext_op { ! 264: unsigned int cmd; ! 265: union { ! 266: /* [UN]PIN_TABLE, NEW_BASEPTR, NEW_USER_BASEPTR ! 267: * CLEAR_PAGE, COPY_PAGE */ ! 268: xen_pfn_t mfn; ! 269: /* INVLPG_LOCAL, INVLPG_ALL, SET_LDT */ ! 270: unsigned long linear_addr; ! 271: } arg1; ! 272: union { ! 273: /* SET_LDT */ ! 274: unsigned int nr_ents; ! 275: /* TLB_FLUSH_MULTI, INVLPG_MULTI */ ! 276: #if __XEN_INTERFACE_VERSION__ >= 0x00030205 ! 277: XEN_GUEST_HANDLE(void) vcpumask; ! 278: #else ! 279: void *vcpumask; ! 280: #endif ! 281: /* COPY_PAGE */ ! 282: xen_pfn_t src_mfn; ! 283: } arg2; ! 284: }; ! 285: typedef struct mmuext_op mmuext_op_t; ! 286: DEFINE_XEN_GUEST_HANDLE(mmuext_op_t); ! 287: #endif ! 288: ! 289: /* These are passed as 'flags' to update_va_mapping. They can be ORed. */ ! 290: /* When specifying UVMF_MULTI, also OR in a pointer to a CPU bitmap. */ ! 291: /* UVMF_LOCAL is merely UVMF_MULTI with a NULL bitmap pointer. */ ! 292: #define UVMF_NONE (0UL<<0) /* No flushing at all. */ ! 293: #define UVMF_TLB_FLUSH (1UL<<0) /* Flush entire TLB(s). */ ! 294: #define UVMF_INVLPG (2UL<<0) /* Flush only one entry. */ ! 295: #define UVMF_FLUSHTYPE_MASK (3UL<<0) ! 296: #define UVMF_MULTI (0UL<<2) /* Flush subset of TLBs. */ ! 297: #define UVMF_LOCAL (0UL<<2) /* Flush local TLB. */ ! 298: #define UVMF_ALL (1UL<<2) /* Flush all TLBs. */ ! 299: ! 300: /* ! 301: * Commands to HYPERVISOR_console_io(). ! 302: */ ! 303: #define CONSOLEIO_write 0 ! 304: #define CONSOLEIO_read 1 ! 305: ! 306: /* ! 307: * Commands to HYPERVISOR_vm_assist(). ! 308: */ ! 309: #define VMASST_CMD_enable 0 ! 310: #define VMASST_CMD_disable 1 ! 311: ! 312: /* x86/32 guests: simulate full 4GB segment limits. */ ! 313: #define VMASST_TYPE_4gb_segments 0 ! 314: ! 315: /* x86/32 guests: trap (vector 15) whenever above vmassist is used. */ ! 316: #define VMASST_TYPE_4gb_segments_notify 1 ! 317: ! 318: /* ! 319: * x86 guests: support writes to bottom-level PTEs. ! 320: * NB1. Page-directory entries cannot be written. ! 321: * NB2. Guest must continue to remove all writable mappings of PTEs. ! 322: */ ! 323: #define VMASST_TYPE_writable_pagetables 2 ! 324: ! 325: /* x86/PAE guests: support PDPTs above 4GB. */ ! 326: #define VMASST_TYPE_pae_extended_cr3 3 ! 327: ! 328: #define MAX_VMASST_TYPE 3 ! 329: ! 330: #ifndef __ASSEMBLY__ ! 331: ! 332: typedef uint16_t domid_t; ! 333: ! 334: /* Domain ids >= DOMID_FIRST_RESERVED cannot be used for ordinary domains. */ ! 335: #define DOMID_FIRST_RESERVED (0x7FF0U) ! 336: ! 337: /* DOMID_SELF is used in certain contexts to refer to oneself. */ ! 338: #define DOMID_SELF (0x7FF0U) ! 339: ! 340: /* ! 341: * DOMID_IO is used to restrict page-table updates to mapping I/O memory. ! 342: * Although no Foreign Domain need be specified to map I/O pages, DOMID_IO ! 343: * is useful to ensure that no mappings to the OS's own heap are accidentally ! 344: * installed. (e.g., in Linux this could cause havoc as reference counts ! 345: * aren't adjusted on the I/O-mapping code path). ! 346: * This only makes sense in MMUEXT_SET_FOREIGNDOM, but in that context can ! 347: * be specified by any calling domain. ! 348: */ ! 349: #define DOMID_IO (0x7FF1U) ! 350: ! 351: /* ! 352: * DOMID_XEN is used to allow privileged domains to map restricted parts of ! 353: * Xen's heap space (e.g., the machine_to_phys table). ! 354: * This only makes sense in MMUEXT_SET_FOREIGNDOM, and is only permitted if ! 355: * the caller is privileged. ! 356: */ ! 357: #define DOMID_XEN (0x7FF2U) ! 358: ! 359: /* ! 360: * Send an array of these to HYPERVISOR_mmu_update(). ! 361: * NB. The fields are natural pointer/address size for this architecture. ! 362: */ ! 363: struct mmu_update { ! 364: uint64_t ptr; /* Machine address of PTE. */ ! 365: uint64_t val; /* New contents of PTE. */ ! 366: }; ! 367: typedef struct mmu_update mmu_update_t; ! 368: DEFINE_XEN_GUEST_HANDLE(mmu_update_t); ! 369: ! 370: /* ! 371: * Send an array of these to HYPERVISOR_multicall(). ! 372: * NB. The fields are natural register size for this architecture. ! 373: */ ! 374: struct multicall_entry { ! 375: unsigned long op, result; ! 376: unsigned long args[6]; ! 377: }; ! 378: typedef struct multicall_entry multicall_entry_t; ! 379: DEFINE_XEN_GUEST_HANDLE(multicall_entry_t); ! 380: ! 381: /* ! 382: * Event channel endpoints per domain: ! 383: * 1024 if a long is 32 bits; 4096 if a long is 64 bits. ! 384: */ ! 385: #define NR_EVENT_CHANNELS (sizeof(unsigned long) * sizeof(unsigned long) * 64) ! 386: ! 387: struct vcpu_time_info { ! 388: /* ! 389: * Updates to the following values are preceded and followed by an ! 390: * increment of 'version'. The guest can therefore detect updates by ! 391: * looking for changes to 'version'. If the least-significant bit of ! 392: * the version number is set then an update is in progress and the guest ! 393: * must wait to read a consistent set of values. ! 394: * The correct way to interact with the version number is similar to ! 395: * Linux's seqlock: see the implementations of read_seqbegin/read_seqretry. ! 396: */ ! 397: uint32_t version; ! 398: uint32_t pad0; ! 399: uint64_t tsc_timestamp; /* TSC at last update of time vals. */ ! 400: uint64_t system_time; /* Time, in nanosecs, since boot. */ ! 401: /* ! 402: * Current system time: ! 403: * system_time + ! 404: * ((((tsc - tsc_timestamp) << tsc_shift) * tsc_to_system_mul) >> 32) ! 405: * CPU frequency (Hz): ! 406: * ((10^9 << 32) / tsc_to_system_mul) >> tsc_shift ! 407: */ ! 408: uint32_t tsc_to_system_mul; ! 409: int8_t tsc_shift; ! 410: int8_t pad1[3]; ! 411: }; /* 32 bytes */ ! 412: typedef struct vcpu_time_info vcpu_time_info_t; ! 413: ! 414: struct vcpu_info { ! 415: /* ! 416: * 'evtchn_upcall_pending' is written non-zero by Xen to indicate ! 417: * a pending notification for a particular VCPU. It is then cleared ! 418: * by the guest OS /before/ checking for pending work, thus avoiding ! 419: * a set-and-check race. Note that the mask is only accessed by Xen ! 420: * on the CPU that is currently hosting the VCPU. This means that the ! 421: * pending and mask flags can be updated by the guest without special ! 422: * synchronisation (i.e., no need for the x86 LOCK prefix). ! 423: * This may seem suboptimal because if the pending flag is set by ! 424: * a different CPU then an IPI may be scheduled even when the mask ! 425: * is set. However, note: ! 426: * 1. The task of 'interrupt holdoff' is covered by the per-event- ! 427: * channel mask bits. A 'noisy' event that is continually being ! 428: * triggered can be masked at source at this very precise ! 429: * granularity. ! 430: * 2. The main purpose of the per-VCPU mask is therefore to restrict ! 431: * reentrant execution: whether for concurrency control, or to ! 432: * prevent unbounded stack usage. Whatever the purpose, we expect ! 433: * that the mask will be asserted only for short periods at a time, ! 434: * and so the likelihood of a 'spurious' IPI is suitably small. ! 435: * The mask is read before making an event upcall to the guest: a ! 436: * non-zero mask therefore guarantees that the VCPU will not receive ! 437: * an upcall activation. The mask is cleared when the VCPU requests ! 438: * to block: this avoids wakeup-waiting races. ! 439: */ ! 440: uint8_t evtchn_upcall_pending; ! 441: uint8_t evtchn_upcall_mask; ! 442: unsigned long evtchn_pending_sel; ! 443: struct arch_vcpu_info arch; ! 444: struct vcpu_time_info time; ! 445: }; /* 64 bytes (x86) */ ! 446: #ifndef __XEN__ ! 447: typedef struct vcpu_info vcpu_info_t; ! 448: #endif ! 449: ! 450: /* ! 451: * Xen/kernel shared data -- pointer provided in start_info. ! 452: * ! 453: * This structure is defined to be both smaller than a page, and the ! 454: * only data on the shared page, but may vary in actual size even within ! 455: * compatible Xen versions; guests should not rely on the size ! 456: * of this structure remaining constant. ! 457: */ ! 458: struct shared_info { ! 459: struct vcpu_info vcpu_info[MAX_VIRT_CPUS]; ! 460: ! 461: /* ! 462: * A domain can create "event channels" on which it can send and receive ! 463: * asynchronous event notifications. There are three classes of event that ! 464: * are delivered by this mechanism: ! 465: * 1. Bi-directional inter- and intra-domain connections. Domains must ! 466: * arrange out-of-band to set up a connection (usually by allocating ! 467: * an unbound 'listener' port and avertising that via a storage service ! 468: * such as xenstore). ! 469: * 2. Physical interrupts. A domain with suitable hardware-access ! 470: * privileges can bind an event-channel port to a physical interrupt ! 471: * source. ! 472: * 3. Virtual interrupts ('events'). A domain can bind an event-channel ! 473: * port to a virtual interrupt source, such as the virtual-timer ! 474: * device or the emergency console. ! 475: * ! 476: * Event channels are addressed by a "port index". Each channel is ! 477: * associated with two bits of information: ! 478: * 1. PENDING -- notifies the domain that there is a pending notification ! 479: * to be processed. This bit is cleared by the guest. ! 480: * 2. MASK -- if this bit is clear then a 0->1 transition of PENDING ! 481: * will cause an asynchronous upcall to be scheduled. This bit is only ! 482: * updated by the guest. It is read-only within Xen. If a channel ! 483: * becomes pending while the channel is masked then the 'edge' is lost ! 484: * (i.e., when the channel is unmasked, the guest must manually handle ! 485: * pending notifications as no upcall will be scheduled by Xen). ! 486: * ! 487: * To expedite scanning of pending notifications, any 0->1 pending ! 488: * transition on an unmasked channel causes a corresponding bit in a ! 489: * per-vcpu selector word to be set. Each bit in the selector covers a ! 490: * 'C long' in the PENDING bitfield array. ! 491: */ ! 492: unsigned long evtchn_pending[sizeof(unsigned long) * 8]; ! 493: unsigned long evtchn_mask[sizeof(unsigned long) * 8]; ! 494: ! 495: /* ! 496: * Wallclock time: updated only by control software. Guests should base ! 497: * their gettimeofday() syscall on this wallclock-base value. ! 498: */ ! 499: uint32_t wc_version; /* Version counter: see vcpu_time_info_t. */ ! 500: uint32_t wc_sec; /* Secs 00:00:00 UTC, Jan 1, 1970. */ ! 501: uint32_t wc_nsec; /* Nsecs 00:00:00 UTC, Jan 1, 1970. */ ! 502: ! 503: struct arch_shared_info arch; ! 504: ! 505: }; ! 506: #ifndef __XEN__ ! 507: typedef struct shared_info shared_info_t; ! 508: #endif ! 509: ! 510: /* ! 511: * Start-of-day memory layout: ! 512: * 1. The domain is started within contiguous virtual-memory region. ! 513: * 2. The contiguous region ends on an aligned 4MB boundary. ! 514: * 3. This the order of bootstrap elements in the initial virtual region: ! 515: * a. relocated kernel image ! 516: * b. initial ram disk [mod_start, mod_len] ! 517: * c. list of allocated page frames [mfn_list, nr_pages] ! 518: * d. start_info_t structure [register ESI (x86)] ! 519: * e. bootstrap page tables [pt_base, CR3 (x86)] ! 520: * f. bootstrap stack [register ESP (x86)] ! 521: * 4. Bootstrap elements are packed together, but each is 4kB-aligned. ! 522: * 5. The initial ram disk may be omitted. ! 523: * 6. The list of page frames forms a contiguous 'pseudo-physical' memory ! 524: * layout for the domain. In particular, the bootstrap virtual-memory ! 525: * region is a 1:1 mapping to the first section of the pseudo-physical map. ! 526: * 7. All bootstrap elements are mapped read-writable for the guest OS. The ! 527: * only exception is the bootstrap page table, which is mapped read-only. ! 528: * 8. There is guaranteed to be at least 512kB padding after the final ! 529: * bootstrap element. If necessary, the bootstrap virtual region is ! 530: * extended by an extra 4MB to ensure this. ! 531: */ ! 532: ! 533: #define MAX_GUEST_CMDLINE 1024 ! 534: struct start_info { ! 535: /* THE FOLLOWING ARE FILLED IN BOTH ON INITIAL BOOT AND ON RESUME. */ ! 536: char magic[32]; /* "xen-<version>-<platform>". */ ! 537: unsigned long nr_pages; /* Total pages allocated to this domain. */ ! 538: unsigned long shared_info; /* MACHINE address of shared info struct. */ ! 539: uint32_t flags; /* SIF_xxx flags. */ ! 540: xen_pfn_t store_mfn; /* MACHINE page number of shared page. */ ! 541: uint32_t store_evtchn; /* Event channel for store communication. */ ! 542: union { ! 543: struct { ! 544: xen_pfn_t mfn; /* MACHINE page number of console page. */ ! 545: uint32_t evtchn; /* Event channel for console page. */ ! 546: } domU; ! 547: struct { ! 548: uint32_t info_off; /* Offset of console_info struct. */ ! 549: uint32_t info_size; /* Size of console_info struct from start.*/ ! 550: } dom0; ! 551: } console; ! 552: /* THE FOLLOWING ARE ONLY FILLED IN ON INITIAL BOOT (NOT RESUME). */ ! 553: unsigned long pt_base; /* VIRTUAL address of page directory. */ ! 554: unsigned long nr_pt_frames; /* Number of bootstrap p.t. frames. */ ! 555: unsigned long mfn_list; /* VIRTUAL address of page-frame list. */ ! 556: unsigned long mod_start; /* VIRTUAL address of pre-loaded module. */ ! 557: unsigned long mod_len; /* Size (bytes) of pre-loaded module. */ ! 558: int8_t cmd_line[MAX_GUEST_CMDLINE]; ! 559: ! 560: /* hackish, for multiboot compatibility */ ! 561: unsigned mods_count; ! 562: }; ! 563: typedef struct start_info start_info_t; ! 564: ! 565: /* New console union for dom0 introduced in 0x00030203. */ ! 566: #if __XEN_INTERFACE_VERSION__ < 0x00030203 ! 567: #define console_mfn console.domU.mfn ! 568: #define console_evtchn console.domU.evtchn ! 569: #endif ! 570: ! 571: /* These flags are passed in the 'flags' field of start_info_t. */ ! 572: #define SIF_PRIVILEGED (1<<0) /* Is the domain privileged? */ ! 573: #define SIF_INITDOMAIN (1<<1) /* Is this the initial control domain? */ ! 574: #define SIF_MULTIBOOT_MOD (1<<2) /* Is this the initial control domain? */ ! 575: #define SIF_PM_MASK (0xFF<<8) /* reserve 1 byte for xen-pm options */ ! 576: ! 577: typedef struct dom0_vga_console_info { ! 578: uint8_t video_type; /* DOM0_VGA_CONSOLE_??? */ ! 579: #define XEN_VGATYPE_TEXT_MODE_3 0x03 ! 580: #define XEN_VGATYPE_VESA_LFB 0x23 ! 581: ! 582: union { ! 583: struct { ! 584: /* Font height, in pixels. */ ! 585: uint16_t font_height; ! 586: /* Cursor location (column, row). */ ! 587: uint16_t cursor_x, cursor_y; ! 588: /* Number of rows and columns (dimensions in characters). */ ! 589: uint16_t rows, columns; ! 590: } text_mode_3; ! 591: ! 592: struct { ! 593: /* Width and height, in pixels. */ ! 594: uint16_t width, height; ! 595: /* Bytes per scan line. */ ! 596: uint16_t bytes_per_line; ! 597: /* Bits per pixel. */ ! 598: uint16_t bits_per_pixel; ! 599: /* LFB physical address, and size (in units of 64kB). */ ! 600: uint32_t lfb_base; ! 601: uint32_t lfb_size; ! 602: /* RGB mask offsets and sizes, as defined by VBE 1.2+ */ ! 603: uint8_t red_pos, red_size; ! 604: uint8_t green_pos, green_size; ! 605: uint8_t blue_pos, blue_size; ! 606: uint8_t rsvd_pos, rsvd_size; ! 607: #if __XEN_INTERFACE_VERSION__ >= 0x00030206 ! 608: /* VESA capabilities (offset 0xa, VESA command 0x4f00). */ ! 609: uint32_t gbl_caps; ! 610: /* Mode attributes (offset 0x0, VESA command 0x4f01). */ ! 611: uint16_t mode_attrs; ! 612: #endif ! 613: } vesa_lfb; ! 614: } u; ! 615: } dom0_vga_console_info_t; ! 616: #define xen_vga_console_info dom0_vga_console_info ! 617: #define xen_vga_console_info_t dom0_vga_console_info_t ! 618: ! 619: typedef uint8_t xen_domain_handle_t[16]; ! 620: ! 621: /* Turn a plain number into a C unsigned long constant. */ ! 622: #define __mk_unsigned_long(x) x ## UL ! 623: #define mk_unsigned_long(x) __mk_unsigned_long(x) ! 624: ! 625: __DEFINE_XEN_GUEST_HANDLE(uint8, uint8_t); ! 626: __DEFINE_XEN_GUEST_HANDLE(uint16, uint16_t); ! 627: __DEFINE_XEN_GUEST_HANDLE(uint32, uint32_t); ! 628: __DEFINE_XEN_GUEST_HANDLE(uint64, uint64_t); ! 629: ! 630: #else /* __ASSEMBLY__ */ ! 631: ! 632: /* In assembly code we cannot use C numeric constant suffixes. */ ! 633: #define mk_unsigned_long(x) x ! 634: ! 635: #endif /* !__ASSEMBLY__ */ ! 636: ! 637: /* Default definitions for macros used by domctl/sysctl. */ ! 638: #if defined(__XEN__) || defined(__XEN_TOOLS__) ! 639: #ifndef uint64_aligned_t ! 640: #define uint64_aligned_t uint64_t ! 641: #endif ! 642: #ifndef XEN_GUEST_HANDLE_64 ! 643: #define XEN_GUEST_HANDLE_64(name) XEN_GUEST_HANDLE(name) ! 644: #endif ! 645: #endif ! 646: ! 647: #endif /* __XEN_PUBLIC_XEN_H__ */ ! 648: ! 649: /* ! 650: * Local variables: ! 651: * mode: C ! 652: * c-set-style: "BSD" ! 653: * c-basic-offset: 4 ! 654: * tab-width: 4 ! 655: * indent-tabs-mode: nil ! 656: * End: ! 657: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.