pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const __bool_true_false_are_defined: u32 = 1;
pub const INVALID_PADDR: i32 = -1;
pub const PRIpaddr: &'static [u8; 6usize] = b"016lx\0";
pub const INT8_MIN: i32 = -128;
pub const INT16_MIN: i32 = -32768;
pub const INT32_MIN: i32 = -2147483648;
pub const INT8_MAX: u32 = 127;
pub const INT16_MAX: u32 = 32767;
pub const INT32_MAX: u32 = 2147483647;
pub const UINT8_MAX: u32 = 255;
pub const UINT16_MAX: u32 = 65535;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT_MAX: i32 = -1;
pub const ULONG_MAX: i32 = -1;
pub const __XEN_LATEST_INTERFACE_VERSION__: u32 = 265728;
pub const __XEN_INTERFACE_VERSION__: u32 = 0;
pub const FLAT_RING3_CS32: u32 = 57379;
pub const FLAT_RING3_CS64: u32 = 57395;
pub const FLAT_RING3_DS32: u32 = 57387;
pub const FLAT_RING3_DS64: u32 = 0;
pub const FLAT_RING3_SS32: u32 = 57387;
pub const FLAT_RING3_SS64: u32 = 57387;
pub const FLAT_KERNEL_DS64: u32 = 0;
pub const FLAT_KERNEL_DS32: u32 = 57387;
pub const FLAT_KERNEL_DS: u32 = 0;
pub const FLAT_KERNEL_CS64: u32 = 57395;
pub const FLAT_KERNEL_CS32: u32 = 57379;
pub const FLAT_KERNEL_CS: u32 = 57395;
pub const FLAT_KERNEL_SS64: u32 = 57387;
pub const FLAT_KERNEL_SS32: u32 = 57387;
pub const FLAT_KERNEL_SS: u32 = 57387;
pub const FLAT_USER_DS64: u32 = 0;
pub const FLAT_USER_DS32: u32 = 57387;
pub const FLAT_USER_DS: u32 = 0;
pub const FLAT_USER_CS64: u32 = 57395;
pub const FLAT_USER_CS32: u32 = 57379;
pub const FLAT_USER_CS: u32 = 57395;
pub const FLAT_USER_SS64: u32 = 57387;
pub const FLAT_USER_SS32: u32 = 57387;
pub const FLAT_USER_SS: u32 = 57387;
pub const __HYPERVISOR_VIRT_START: i64 = -140737488355328;
pub const __HYPERVISOR_VIRT_END: i64 = -131941395333120;
pub const __MACH2PHYS_VIRT_START: i64 = -140737488355328;
pub const __MACH2PHYS_VIRT_END: i64 = -140462610448384;
pub const SEGBASE_FS: u32 = 0;
pub const SEGBASE_GS_USER: u32 = 1;
pub const SEGBASE_GS_KERNEL: u32 = 2;
pub const SEGBASE_GS_USER_SEL: u32 = 3;
pub const _VGCF_in_syscall: u32 = 8;
pub const VGCF_in_syscall: u32 = 256;
pub const VGCF_IN_SYSCALL: u32 = 256;
pub const PRI_xen_pfn: &'static [u8; 3usize] = b"lx\0";
pub const PRIu_xen_pfn: &'static [u8; 3usize] = b"lu\0";
pub const XEN_HAVE_PV_GUEST_ENTRY: u32 = 1;
pub const XEN_HAVE_PV_UPCALL_MASK: u32 = 1;
pub const FIRST_RESERVED_GDT_PAGE: u32 = 14;
pub const FIRST_RESERVED_GDT_BYTE: u32 = 57344;
pub const FIRST_RESERVED_GDT_ENTRY: u32 = 7168;
pub const XEN_LEGACY_MAX_VCPUS: u32 = 32;
pub const PRI_xen_ulong: &'static [u8; 3usize] = b"lx\0";
pub const VGCF_I387_VALID: u32 = 1;
pub const VGCF_IN_KERNEL: u32 = 4;
pub const _VGCF_i387_valid: u32 = 0;
pub const VGCF_i387_valid: u32 = 1;
pub const _VGCF_in_kernel: u32 = 2;
pub const VGCF_in_kernel: u32 = 4;
pub const _VGCF_failsafe_disables_events: u32 = 3;
pub const VGCF_failsafe_disables_events: u32 = 8;
pub const _VGCF_syscall_disables_events: u32 = 4;
pub const VGCF_syscall_disables_events: u32 = 16;
pub const _VGCF_online: u32 = 5;
pub const VGCF_online: u32 = 32;
pub const XEN_CPUID_NO_SUBLEAF: u32 = 4294967295;
pub const XEN_EMULATE_PREFIX: &'static [u8; 34usize] = b".byte 0x0f,0x0b,0x78,0x65,0x6e ; \0";
pub const XEN_CPUID: &'static [u8; 39usize] = b".byte 0x0f,0x0b,0x78,0x65,0x6e ; cpuid\0";
pub const XEN_HVM_DEBUGCONS_IOPORT: u32 = 233;
pub const __HYPERVISOR_set_trap_table: u32 = 0;
pub const __HYPERVISOR_mmu_update: u32 = 1;
pub const __HYPERVISOR_set_gdt: u32 = 2;
pub const __HYPERVISOR_stack_switch: u32 = 3;
pub const __HYPERVISOR_set_callbacks: u32 = 4;
pub const __HYPERVISOR_fpu_taskswitch: u32 = 5;
pub const __HYPERVISOR_sched_op_compat: u32 = 6;
pub const __HYPERVISOR_platform_op: u32 = 7;
pub const __HYPERVISOR_set_debugreg: u32 = 8;
pub const __HYPERVISOR_get_debugreg: u32 = 9;
pub const __HYPERVISOR_update_descriptor: u32 = 10;
pub const __HYPERVISOR_memory_op: u32 = 12;
pub const __HYPERVISOR_multicall: u32 = 13;
pub const __HYPERVISOR_update_va_mapping: u32 = 14;
pub const __HYPERVISOR_set_timer_op: u32 = 15;
pub const __HYPERVISOR_event_channel_op_compat: u32 = 16;
pub const __HYPERVISOR_xen_version: u32 = 17;
pub const __HYPERVISOR_console_io: u32 = 18;
pub const __HYPERVISOR_physdev_op_compat: u32 = 19;
pub const __HYPERVISOR_grant_table_op: u32 = 20;
pub const __HYPERVISOR_vm_assist: u32 = 21;
pub const __HYPERVISOR_update_va_mapping_otherdomain: u32 = 22;
pub const __HYPERVISOR_iret: u32 = 23;
pub const __HYPERVISOR_vcpu_op: u32 = 24;
pub const __HYPERVISOR_set_segment_base: u32 = 25;
pub const __HYPERVISOR_mmuext_op: u32 = 26;
pub const __HYPERVISOR_xsm_op: u32 = 27;
pub const __HYPERVISOR_nmi_op: u32 = 28;
pub const __HYPERVISOR_sched_op: u32 = 29;
pub const __HYPERVISOR_callback_op: u32 = 30;
pub const __HYPERVISOR_xenoprof_op: u32 = 31;
pub const __HYPERVISOR_event_channel_op: u32 = 32;
pub const __HYPERVISOR_physdev_op: u32 = 33;
pub const __HYPERVISOR_hvm_op: u32 = 34;
pub const __HYPERVISOR_sysctl: u32 = 35;
pub const __HYPERVISOR_domctl: u32 = 36;
pub const __HYPERVISOR_kexec_op: u32 = 37;
pub const __HYPERVISOR_tmem_op: u32 = 38;
pub const __HYPERVISOR_argo_op: u32 = 39;
pub const __HYPERVISOR_xenpmu_op: u32 = 40;
pub const __HYPERVISOR_dm_op: u32 = 41;
pub const __HYPERVISOR_hypfs_op: u32 = 42;
pub const __HYPERVISOR_arch_0: u32 = 48;
pub const __HYPERVISOR_arch_1: u32 = 49;
pub const __HYPERVISOR_arch_2: u32 = 50;
pub const __HYPERVISOR_arch_3: u32 = 51;
pub const __HYPERVISOR_arch_4: u32 = 52;
pub const __HYPERVISOR_arch_5: u32 = 53;
pub const __HYPERVISOR_arch_6: u32 = 54;
pub const __HYPERVISOR_arch_7: u32 = 55;
pub const __HYPERVISOR_dom0_op: u32 = 7;
pub const VIRQ_TIMER: u32 = 0;
pub const VIRQ_DEBUG: u32 = 1;
pub const VIRQ_CONSOLE: u32 = 2;
pub const VIRQ_DOM_EXC: u32 = 3;
pub const VIRQ_TBUF: u32 = 4;
pub const VIRQ_DEBUGGER: u32 = 6;
pub const VIRQ_XENOPROF: u32 = 7;
pub const VIRQ_CON_RING: u32 = 8;
pub const VIRQ_PCPU_STATE: u32 = 9;
pub const VIRQ_MEM_EVENT: u32 = 10;
pub const VIRQ_ARGO: u32 = 11;
pub const VIRQ_ENOMEM: u32 = 12;
pub const VIRQ_XENPMU: u32 = 13;
pub const VIRQ_ARCH_0: u32 = 16;
pub const VIRQ_ARCH_1: u32 = 17;
pub const VIRQ_ARCH_2: u32 = 18;
pub const VIRQ_ARCH_3: u32 = 19;
pub const VIRQ_ARCH_4: u32 = 20;
pub const VIRQ_ARCH_5: u32 = 21;
pub const VIRQ_ARCH_6: u32 = 22;
pub const VIRQ_ARCH_7: u32 = 23;
pub const NR_VIRQS: u32 = 24;
pub const MMU_NORMAL_PT_UPDATE: u32 = 0;
pub const MMU_MACHPHYS_UPDATE: u32 = 1;
pub const MMU_PT_UPDATE_PRESERVE_AD: u32 = 2;
pub const MMU_PT_UPDATE_NO_TRANSLATE: u32 = 3;
pub const MMUEXT_PIN_L1_TABLE: u32 = 0;
pub const MMUEXT_PIN_L2_TABLE: u32 = 1;
pub const MMUEXT_PIN_L3_TABLE: u32 = 2;
pub const MMUEXT_PIN_L4_TABLE: u32 = 3;
pub const MMUEXT_UNPIN_TABLE: u32 = 4;
pub const MMUEXT_NEW_BASEPTR: u32 = 5;
pub const MMUEXT_TLB_FLUSH_LOCAL: u32 = 6;
pub const MMUEXT_INVLPG_LOCAL: u32 = 7;
pub const MMUEXT_TLB_FLUSH_MULTI: u32 = 8;
pub const MMUEXT_INVLPG_MULTI: u32 = 9;
pub const MMUEXT_TLB_FLUSH_ALL: u32 = 10;
pub const MMUEXT_INVLPG_ALL: u32 = 11;
pub const MMUEXT_FLUSH_CACHE: u32 = 12;
pub const MMUEXT_SET_LDT: u32 = 13;
pub const MMUEXT_NEW_USER_BASEPTR: u32 = 15;
pub const MMUEXT_CLEAR_PAGE: u32 = 16;
pub const MMUEXT_COPY_PAGE: u32 = 17;
pub const MMUEXT_FLUSH_CACHE_GLOBAL: u32 = 18;
pub const MMUEXT_MARK_SUPER: u32 = 19;
pub const MMUEXT_UNMARK_SUPER: u32 = 20;
pub const CONSOLEIO_write: u32 = 0;
pub const CONSOLEIO_read: u32 = 1;
pub const VMASST_CMD_enable: u32 = 0;
pub const VMASST_CMD_disable: u32 = 1;
pub const VMASST_TYPE_4gb_segments: u32 = 0;
pub const VMASST_TYPE_4gb_segments_notify: u32 = 1;
pub const VMASST_TYPE_writable_pagetables: u32 = 2;
pub const VMASST_TYPE_pae_extended_cr3: u32 = 3;
pub const VMASST_TYPE_architectural_iopl: u32 = 4;
pub const VMASST_TYPE_runstate_update_flag: u32 = 5;
pub const VMASST_TYPE_m2p_strict: u32 = 32;
pub const MAX_VMASST_TYPE: u32 = 3;
pub const XEN_PVCLOCK_TSC_STABLE_BIT: u32 = 1;
pub const XEN_PVCLOCK_GUEST_STOPPED: u32 = 2;
pub const MAX_GUEST_CMDLINE: u32 = 1024;
pub const SIF_PRIVILEGED: u32 = 1;
pub const SIF_INITDOMAIN: u32 = 2;
pub const SIF_MULTIBOOT_MOD: u32 = 4;
pub const SIF_MOD_START_PFN: u32 = 8;
pub const SIF_VIRT_P2M_4TOOLS: u32 = 16;
pub const SIF_PM_MASK: u32 = 65280;
pub const XEN_VGATYPE_TEXT_MODE_3: u32 = 3;
pub const XEN_VGATYPE_VESA_LFB: u32 = 35;
pub const XEN_VGATYPE_EFI_LFB: u32 = 112;
pub const EVTCHNOP_bind_interdomain: u32 = 0;
pub const EVTCHNOP_bind_virq: u32 = 1;
pub const EVTCHNOP_bind_pirq: u32 = 2;
pub const EVTCHNOP_close: u32 = 3;
pub const EVTCHNOP_send: u32 = 4;
pub const EVTCHNOP_status: u32 = 5;
pub const EVTCHNOP_alloc_unbound: u32 = 6;
pub const EVTCHNOP_bind_ipi: u32 = 7;
pub const EVTCHNOP_bind_vcpu: u32 = 8;
pub const EVTCHNOP_unmask: u32 = 9;
pub const EVTCHNOP_reset: u32 = 10;
pub const EVTCHNOP_init_control: u32 = 11;
pub const EVTCHNOP_expand_array: u32 = 12;
pub const EVTCHNOP_set_priority: u32 = 13;
pub const BIND_PIRQ__WILL_SHARE: u32 = 1;
pub const EVTCHNSTAT_closed: u32 = 0;
pub const EVTCHNSTAT_unbound: u32 = 1;
pub const EVTCHNSTAT_interdomain: u32 = 2;
pub const EVTCHNSTAT_pirq: u32 = 3;
pub const EVTCHNSTAT_virq: u32 = 4;
pub const EVTCHNSTAT_ipi: u32 = 5;
pub const EVTCHN_FIFO_PRIORITY_MAX: u32 = 0;
pub const EVTCHN_FIFO_PRIORITY_DEFAULT: u32 = 7;
pub const EVTCHN_FIFO_PRIORITY_MIN: u32 = 15;
pub const EVTCHN_FIFO_MAX_QUEUES: u32 = 16;
pub const EVTCHN_FIFO_PENDING: u32 = 31;
pub const EVTCHN_FIFO_MASKED: u32 = 30;
pub const EVTCHN_FIFO_LINKED: u32 = 29;
pub const EVTCHN_FIFO_BUSY: u32 = 28;
pub const EVTCHN_FIFO_LINK_BITS: u32 = 17;
pub const EVTCHN_FIFO_LINK_MASK: u32 = 131071;
pub const EVTCHN_FIFO_NR_CHANNELS: u32 = 131072;
pub const SCHEDOP_yield: u32 = 0;
pub const SCHEDOP_block: u32 = 1;
pub const SCHEDOP_shutdown: u32 = 2;
pub const SCHEDOP_poll: u32 = 3;
pub const SCHEDOP_remote_shutdown: u32 = 4;
pub const SCHEDOP_shutdown_code: u32 = 5;
pub const SCHEDOP_watchdog: u32 = 6;
pub const SCHEDOP_pin_override: u32 = 7;
pub const SHUTDOWN_poweroff: u32 = 0;
pub const SHUTDOWN_reboot: u32 = 1;
pub const SHUTDOWN_suspend: u32 = 2;
pub const SHUTDOWN_crash: u32 = 3;
pub const SHUTDOWN_watchdog: u32 = 4;
pub const SHUTDOWN_soft_reset: u32 = 5;
pub const SHUTDOWN_MAX: u32 = 5;
pub const XEN_ELFNOTE_INFO: u32 = 0;
pub const XEN_ELFNOTE_ENTRY: u32 = 1;
pub const XEN_ELFNOTE_HYPERCALL_PAGE: u32 = 2;
pub const XEN_ELFNOTE_VIRT_BASE: u32 = 3;
pub const XEN_ELFNOTE_PADDR_OFFSET: u32 = 4;
pub const XEN_ELFNOTE_XEN_VERSION: u32 = 5;
pub const XEN_ELFNOTE_GUEST_OS: u32 = 6;
pub const XEN_ELFNOTE_GUEST_VERSION: u32 = 7;
pub const XEN_ELFNOTE_LOADER: u32 = 8;
pub const XEN_ELFNOTE_PAE_MODE: u32 = 9;
pub const XEN_ELFNOTE_FEATURES: u32 = 10;
pub const XEN_ELFNOTE_BSD_SYMTAB: u32 = 11;
pub const XEN_ELFNOTE_HV_START_LOW: u32 = 12;
pub const XEN_ELFNOTE_L1_MFN_VALID: u32 = 13;
pub const XEN_ELFNOTE_SUSPEND_CANCEL: u32 = 14;
pub const XEN_ELFNOTE_INIT_P2M: u32 = 15;
pub const XEN_ELFNOTE_MOD_START_PFN: u32 = 16;
pub const XEN_ELFNOTE_SUPPORTED_FEATURES: u32 = 17;
pub const XEN_ELFNOTE_PHYS32_ENTRY: u32 = 18;
pub const XEN_ELFNOTE_MAX: u32 = 18;
pub const XEN_ELFNOTE_CRASH_INFO: u32 = 16777217;
pub const XEN_ELFNOTE_CRASH_REGS: u32 = 16777218;
pub const XEN_ELFNOTE_DUMPCORE_NONE: u32 = 33554432;
pub const XEN_ELFNOTE_DUMPCORE_HEADER: u32 = 33554433;
pub const XEN_ELFNOTE_DUMPCORE_XEN_VERSION: u32 = 33554434;
pub const XEN_ELFNOTE_DUMPCORE_FORMAT_VERSION: u32 = 33554435;
pub type __s8 = cty::c_schar;
pub type __u8 = cty::c_uchar;
pub type __s16 = cty::c_short;
pub type __u16 = cty::c_ushort;
pub type __s32 = cty::c_int;
pub type __u32 = cty::c_uint;
pub type __s64 = cty::c_long;
pub type __u64 = cty::c_ulong;
pub type s8 = cty::c_schar;
pub type u8_ = cty::c_uchar;
pub type s16 = cty::c_short;
pub type u16_ = cty::c_ushort;
pub type s32 = cty::c_int;
pub type u32_ = cty::c_uint;
pub type s64 = cty::c_long;
pub type u64_ = cty::c_ulong;
pub type paddr_t = cty::c_ulong;
pub type size_t = cty::c_ulong;
pub type ssize_t = cty::c_long;
pub type __le16 = __u16;
pub type __be16 = __u16;
pub type __le32 = __u32;
pub type __be32 = __u32;
pub type __le64 = __u64;
pub type __be64 = __u64;
pub type bool_t = bool;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct iret_context {
pub rax: u64,
pub r11: u64,
pub rcx: u64,
pub flags: u64,
pub rip: u64,
pub cs: u64,
pub rflags: u64,
pub rsp: u64,
pub ss: u64,
}
#[test]
fn bindgen_test_layout_iret_context() {
assert_eq!(
::core::mem::size_of::<iret_context>(),
72usize,
concat!("Size of: ", stringify!(iret_context))
);
assert_eq!(
::core::mem::align_of::<iret_context>(),
8usize,
concat!("Alignment of ", stringify!(iret_context))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).rax as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(rax)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).r11 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(r11)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).rcx as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(rcx)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).flags as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).rip as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(rip)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).cs as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(cs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).rflags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(rflags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).rsp as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(rsp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<iret_context>())).ss as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(iret_context),
"::",
stringify!(ss)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct cpu_user_regs {
pub r15: u64,
pub r14: u64,
pub r13: u64,
pub r12: u64,
pub __bindgen_anon_1: cpu_user_regs__bindgen_ty_1,
pub __bindgen_anon_2: cpu_user_regs__bindgen_ty_2,
pub r11: u64,
pub r10: u64,
pub r9: u64,
pub r8: u64,
pub __bindgen_anon_3: cpu_user_regs__bindgen_ty_3,
pub __bindgen_anon_4: cpu_user_regs__bindgen_ty_4,
pub __bindgen_anon_5: cpu_user_regs__bindgen_ty_5,
pub __bindgen_anon_6: cpu_user_regs__bindgen_ty_6,
pub __bindgen_anon_7: cpu_user_regs__bindgen_ty_7,
pub error_code: u32,
pub entry_vector: u32,
pub __bindgen_anon_8: cpu_user_regs__bindgen_ty_8,
pub cs: u16,
pub _pad0: [u16; 1usize],
pub saved_upcall_mask: u8,
pub _pad1: [u8; 3usize],
pub __bindgen_anon_9: cpu_user_regs__bindgen_ty_9,
pub __bindgen_anon_10: cpu_user_regs__bindgen_ty_10,
pub ss: u16,
pub _pad2: [u16; 3usize],
pub es: u16,
pub _pad3: [u16; 3usize],
pub ds: u16,
pub _pad4: [u16; 3usize],
pub fs: u16,
pub _pad5: [u16; 3usize],
pub gs: u16,
pub _pad6: [u16; 3usize],
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_1 {
pub rbp: u64,
pub ebp: u64,
pub _ebp: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_1>())).rbp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_1),
"::",
stringify!(rbp)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_1>())).ebp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_1),
"::",
stringify!(ebp)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_1>()))._ebp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_1),
"::",
stringify!(_ebp)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_2 {
pub rbx: u64,
pub ebx: u64,
pub _ebx: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_2>())).rbx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_2),
"::",
stringify!(rbx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_2>())).ebx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_2),
"::",
stringify!(ebx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_2>()))._ebx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_2),
"::",
stringify!(_ebx)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_3 {
pub rax: u64,
pub eax: u64,
pub _eax: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_3() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_3>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_3))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_3>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_3))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_3>())).rax as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_3),
"::",
stringify!(rax)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_3>())).eax as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_3),
"::",
stringify!(eax)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_3>()))._eax as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_3),
"::",
stringify!(_eax)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_4 {
pub rcx: u64,
pub ecx: u64,
pub _ecx: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_4() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_4>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_4))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_4>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_4))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_4>())).rcx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_4),
"::",
stringify!(rcx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_4>())).ecx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_4),
"::",
stringify!(ecx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_4>()))._ecx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_4),
"::",
stringify!(_ecx)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_5 {
pub rdx: u64,
pub edx: u64,
pub _edx: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_5() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_5>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_5))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_5>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_5))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_5>())).rdx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_5),
"::",
stringify!(rdx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_5>())).edx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_5),
"::",
stringify!(edx)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_5>()))._edx as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_5),
"::",
stringify!(_edx)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_6 {
pub rsi: u64,
pub esi: u64,
pub _esi: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_6() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_6>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_6))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_6>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_6))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_6>())).rsi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_6),
"::",
stringify!(rsi)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_6>())).esi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_6),
"::",
stringify!(esi)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_6>()))._esi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_6),
"::",
stringify!(_esi)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_7 {
pub rdi: u64,
pub edi: u64,
pub _edi: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_7() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_7>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_7))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_7>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_7))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_7>())).rdi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_7),
"::",
stringify!(rdi)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_7>())).edi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_7),
"::",
stringify!(edi)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_7>()))._edi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_7),
"::",
stringify!(_edi)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_8 {
pub rip: u64,
pub eip: u64,
pub _eip: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_8() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_8>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_8))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_8>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_8))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_8>())).rip as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_8),
"::",
stringify!(rip)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_8>())).eip as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_8),
"::",
stringify!(eip)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_8>()))._eip as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_8),
"::",
stringify!(_eip)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_9 {
pub rflags: u64,
pub eflags: u64,
pub _eflags: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_9() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_9>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_9))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_9>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_9))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_9>())).rflags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_9),
"::",
stringify!(rflags)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_9>())).eflags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_9),
"::",
stringify!(eflags)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_9>()))._eflags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_9),
"::",
stringify!(_eflags)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union cpu_user_regs__bindgen_ty_10 {
pub rsp: u64,
pub esp: u64,
pub _esp: u32,
}
#[test]
fn bindgen_test_layout_cpu_user_regs__bindgen_ty_10() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs__bindgen_ty_10>(),
8usize,
concat!("Size of: ", stringify!(cpu_user_regs__bindgen_ty_10))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs__bindgen_ty_10>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs__bindgen_ty_10))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_10>())).rsp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_10),
"::",
stringify!(rsp)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_10>())).esp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_10),
"::",
stringify!(esp)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs__bindgen_ty_10>()))._esp as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs__bindgen_ty_10),
"::",
stringify!(_esp)
)
);
}
#[test]
fn bindgen_test_layout_cpu_user_regs() {
assert_eq!(
::core::mem::size_of::<cpu_user_regs>(),
200usize,
concat!("Size of: ", stringify!(cpu_user_regs))
);
assert_eq!(
::core::mem::align_of::<cpu_user_regs>(),
8usize,
concat!("Alignment of ", stringify!(cpu_user_regs))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r15 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r15)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r14 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r14)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r13 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r13)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r12 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r12)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r11 as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r11)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r10 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r10)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r9 as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r9)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).r8 as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(r8)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).error_code as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(error_code)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).entry_vector as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(entry_vector)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).cs as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(cs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad0 as *const _ as usize },
138usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad0)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<cpu_user_regs>())).saved_upcall_mask as *const _ as usize
},
140usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(saved_upcall_mask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad1 as *const _ as usize },
141usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad1)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).ss as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(ss)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad2 as *const _ as usize },
162usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).es as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(es)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad3 as *const _ as usize },
170usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad3)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).ds as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(ds)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad4 as *const _ as usize },
178usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad4)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).fs as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(fs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad5 as *const _ as usize },
186usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad5)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>())).gs as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(gs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<cpu_user_regs>()))._pad6 as *const _ as usize },
194usize,
concat!(
"Offset of field: ",
stringify!(cpu_user_regs),
"::",
stringify!(_pad6)
)
);
}
pub type cpu_user_regs_t = cpu_user_regs;
pub type __guest_handle_cpu_user_regs_t = *mut cpu_user_regs_t;
pub type __guest_handle_const_cpu_user_regs_t = *const cpu_user_regs_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arch_vcpu_info {
pub cr2: cty::c_ulong,
pub pad: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_arch_vcpu_info() {
assert_eq!(
::core::mem::size_of::<arch_vcpu_info>(),
16usize,
concat!("Size of: ", stringify!(arch_vcpu_info))
);
assert_eq!(
::core::mem::align_of::<arch_vcpu_info>(),
8usize,
concat!("Alignment of ", stringify!(arch_vcpu_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_vcpu_info>())).cr2 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(arch_vcpu_info),
"::",
stringify!(cr2)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_vcpu_info>())).pad as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(arch_vcpu_info),
"::",
stringify!(pad)
)
);
}
pub type arch_vcpu_info_t = arch_vcpu_info;
pub type xen_callback_t = cty::c_ulong;
pub type xen_pfn_t = cty::c_ulong;
pub type xen_ulong_t = cty::c_ulong;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct trap_info {
pub vector: u8,
pub flags: u8,
pub cs: u16,
pub address: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_trap_info() {
assert_eq!(
::core::mem::size_of::<trap_info>(),
16usize,
concat!("Size of: ", stringify!(trap_info))
);
assert_eq!(
::core::mem::align_of::<trap_info>(),
8usize,
concat!("Alignment of ", stringify!(trap_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<trap_info>())).vector as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(trap_info),
"::",
stringify!(vector)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<trap_info>())).flags as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(trap_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<trap_info>())).cs as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(trap_info),
"::",
stringify!(cs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<trap_info>())).address as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(trap_info),
"::",
stringify!(address)
)
);
}
pub type trap_info_t = trap_info;
pub type __guest_handle_trap_info_t = *mut trap_info_t;
pub type __guest_handle_const_trap_info_t = *const trap_info_t;
pub type tsc_timestamp_t = u64;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct vcpu_guest_context {
pub fpu_ctxt: vcpu_guest_context__bindgen_ty_1,
pub flags: cty::c_ulong,
pub user_regs: cpu_user_regs,
pub trap_ctxt: [trap_info; 256usize],
pub ldt_base: cty::c_ulong,
pub ldt_ents: cty::c_ulong,
pub gdt_frames: [cty::c_ulong; 16usize],
pub gdt_ents: cty::c_ulong,
pub kernel_ss: cty::c_ulong,
pub kernel_sp: cty::c_ulong,
pub ctrlreg: [cty::c_ulong; 8usize],
pub debugreg: [cty::c_ulong; 8usize],
pub event_callback_eip: cty::c_ulong,
pub failsafe_callback_eip: cty::c_ulong,
pub syscall_callback_eip: cty::c_ulong,
pub vm_assist: cty::c_ulong,
pub fs_base: u64,
pub gs_base_kernel: u64,
pub gs_base_user: u64,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vcpu_guest_context__bindgen_ty_1 {
pub x: [cty::c_char; 512usize],
}
#[test]
fn bindgen_test_layout_vcpu_guest_context__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<vcpu_guest_context__bindgen_ty_1>(),
512usize,
concat!("Size of: ", stringify!(vcpu_guest_context__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<vcpu_guest_context__bindgen_ty_1>(),
1usize,
concat!(
"Alignment of ",
stringify!(vcpu_guest_context__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context__bindgen_ty_1>())).x as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context__bindgen_ty_1),
"::",
stringify!(x)
)
);
}
#[test]
fn bindgen_test_layout_vcpu_guest_context() {
assert_eq!(
::core::mem::size_of::<vcpu_guest_context>(),
5168usize,
concat!("Size of: ", stringify!(vcpu_guest_context))
);
assert_eq!(
::core::mem::align_of::<vcpu_guest_context>(),
8usize,
concat!("Alignment of ", stringify!(vcpu_guest_context))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).fpu_ctxt as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(fpu_ctxt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).flags as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).user_regs as *const _ as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(user_regs)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).trap_ctxt as *const _ as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(trap_ctxt)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).ldt_base as *const _ as usize },
4816usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(ldt_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).ldt_ents as *const _ as usize },
4824usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(ldt_ents)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).gdt_frames as *const _ as usize },
4832usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(gdt_frames)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).gdt_ents as *const _ as usize },
4960usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(gdt_ents)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).kernel_ss as *const _ as usize },
4968usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(kernel_ss)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).kernel_sp as *const _ as usize },
4976usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(kernel_sp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).ctrlreg as *const _ as usize },
4984usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(ctrlreg)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).debugreg as *const _ as usize },
5048usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(debugreg)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context>())).event_callback_eip as *const _ as usize
},
5112usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(event_callback_eip)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context>())).failsafe_callback_eip as *const _
as usize
},
5120usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(failsafe_callback_eip)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context>())).syscall_callback_eip as *const _
as usize
},
5128usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(syscall_callback_eip)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).vm_assist as *const _ as usize },
5136usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(vm_assist)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_guest_context>())).fs_base as *const _ as usize },
5144usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(fs_base)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context>())).gs_base_kernel as *const _ as usize
},
5152usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(gs_base_kernel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_guest_context>())).gs_base_user as *const _ as usize
},
5160usize,
concat!(
"Offset of field: ",
stringify!(vcpu_guest_context),
"::",
stringify!(gs_base_user)
)
);
}
pub type vcpu_guest_context_t = vcpu_guest_context;
pub type __guest_handle_vcpu_guest_context_t = *mut vcpu_guest_context_t;
pub type __guest_handle_const_vcpu_guest_context_t = *const vcpu_guest_context_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct arch_shared_info {
pub max_pfn: cty::c_ulong,
pub pfn_to_mfn_frame_list_list: xen_pfn_t,
pub nmi_reason: cty::c_ulong,
pub p2m_cr3: cty::c_ulong,
pub p2m_vaddr: cty::c_ulong,
pub p2m_generation: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_arch_shared_info() {
assert_eq!(
::core::mem::size_of::<arch_shared_info>(),
48usize,
concat!("Size of: ", stringify!(arch_shared_info))
);
assert_eq!(
::core::mem::align_of::<arch_shared_info>(),
8usize,
concat!("Alignment of ", stringify!(arch_shared_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_shared_info>())).max_pfn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(max_pfn)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<arch_shared_info>())).pfn_to_mfn_frame_list_list as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(pfn_to_mfn_frame_list_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_shared_info>())).nmi_reason as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(nmi_reason)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_shared_info>())).p2m_cr3 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(p2m_cr3)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<arch_shared_info>())).p2m_vaddr as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(p2m_vaddr)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<arch_shared_info>())).p2m_generation as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(arch_shared_info),
"::",
stringify!(p2m_generation)
)
);
}
pub type arch_shared_info_t = arch_shared_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_cpuid_leaf {
pub leaf: u32,
pub subleaf: u32,
pub a: u32,
pub b: u32,
pub c: u32,
pub d: u32,
}
#[test]
fn bindgen_test_layout_xen_cpuid_leaf() {
assert_eq!(
::core::mem::size_of::<xen_cpuid_leaf>(),
24usize,
concat!("Size of: ", stringify!(xen_cpuid_leaf))
);
assert_eq!(
::core::mem::align_of::<xen_cpuid_leaf>(),
4usize,
concat!("Alignment of ", stringify!(xen_cpuid_leaf))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).leaf as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(leaf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).subleaf as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(subleaf)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).a as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).b as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).c as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(c)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_cpuid_leaf>())).d as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(xen_cpuid_leaf),
"::",
stringify!(d)
)
);
}
pub type xen_cpuid_leaf_t = xen_cpuid_leaf;
pub type __guest_handle_xen_cpuid_leaf_t = *mut xen_cpuid_leaf_t;
pub type __guest_handle_const_xen_cpuid_leaf_t = *const xen_cpuid_leaf_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_msr_entry {
pub idx: u32,
pub flags: u32,
pub val: u64,
}
#[test]
fn bindgen_test_layout_xen_msr_entry() {
assert_eq!(
::core::mem::size_of::<xen_msr_entry>(),
16usize,
concat!("Size of: ", stringify!(xen_msr_entry))
);
assert_eq!(
::core::mem::align_of::<xen_msr_entry>(),
8usize,
concat!("Alignment of ", stringify!(xen_msr_entry))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_msr_entry>())).idx as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xen_msr_entry),
"::",
stringify!(idx)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_msr_entry>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(xen_msr_entry),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_msr_entry>())).val as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(xen_msr_entry),
"::",
stringify!(val)
)
);
}
pub type xen_msr_entry_t = xen_msr_entry;
pub type __guest_handle_xen_msr_entry_t = *mut xen_msr_entry_t;
pub type __guest_handle_const_xen_msr_entry_t = *const xen_msr_entry_t;
pub type __guest_handle_char = *mut cty::c_char;
pub type __guest_handle_const_char = *const cty::c_char;
pub type __guest_handle_uchar = *mut cty::c_uchar;
pub type __guest_handle_const_uchar = *const cty::c_uchar;
pub type __guest_handle_int = *mut cty::c_int;
pub type __guest_handle_const_int = *const cty::c_int;
pub type __guest_handle_uint = *mut cty::c_uint;
pub type __guest_handle_const_uint = *const cty::c_uint;
pub type __guest_handle_long = *mut cty::c_long;
pub type __guest_handle_const_long = *const cty::c_long;
pub type __guest_handle_ulong = *mut cty::c_ulong;
pub type __guest_handle_const_ulong = *const cty::c_ulong;
pub type __guest_handle_void = *mut cty::c_void;
pub type __guest_handle_const_void = *const cty::c_void;
pub type __guest_handle_uint64_t = *mut u64;
pub type __guest_handle_const_uint64_t = *const u64;
pub type __guest_handle_xen_pfn_t = *mut xen_pfn_t;
pub type __guest_handle_const_xen_pfn_t = *const xen_pfn_t;
pub type __guest_handle_xen_ulong_t = *mut xen_ulong_t;
pub type __guest_handle_const_xen_ulong_t = *const xen_ulong_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct mmuext_op {
pub cmd: cty::c_uint,
pub arg1: mmuext_op__bindgen_ty_1,
pub arg2: mmuext_op__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mmuext_op__bindgen_ty_1 {
pub mfn: xen_pfn_t,
pub linear_addr: cty::c_ulong,
}
#[test]
fn bindgen_test_layout_mmuext_op__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<mmuext_op__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(mmuext_op__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<mmuext_op__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(mmuext_op__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmuext_op__bindgen_ty_1>())).mfn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op__bindgen_ty_1),
"::",
stringify!(mfn)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<mmuext_op__bindgen_ty_1>())).linear_addr as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op__bindgen_ty_1),
"::",
stringify!(linear_addr)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union mmuext_op__bindgen_ty_2 {
pub nr_ents: cty::c_uint,
pub vcpumask: *const cty::c_void,
pub src_mfn: xen_pfn_t,
}
#[test]
fn bindgen_test_layout_mmuext_op__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<mmuext_op__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(mmuext_op__bindgen_ty_2))
);
assert_eq!(
::core::mem::align_of::<mmuext_op__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(mmuext_op__bindgen_ty_2))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).nr_ents as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op__bindgen_ty_2),
"::",
stringify!(nr_ents)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).vcpumask as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op__bindgen_ty_2),
"::",
stringify!(vcpumask)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<mmuext_op__bindgen_ty_2>())).src_mfn as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op__bindgen_ty_2),
"::",
stringify!(src_mfn)
)
);
}
#[test]
fn bindgen_test_layout_mmuext_op() {
assert_eq!(
::core::mem::size_of::<mmuext_op>(),
24usize,
concat!("Size of: ", stringify!(mmuext_op))
);
assert_eq!(
::core::mem::align_of::<mmuext_op>(),
8usize,
concat!("Alignment of ", stringify!(mmuext_op))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmuext_op>())).cmd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op),
"::",
stringify!(cmd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmuext_op>())).arg1 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op),
"::",
stringify!(arg1)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmuext_op>())).arg2 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(mmuext_op),
"::",
stringify!(arg2)
)
);
}
pub type mmuext_op_t = mmuext_op;
pub type __guest_handle_mmuext_op_t = *mut mmuext_op_t;
pub type __guest_handle_const_mmuext_op_t = *const mmuext_op_t;
pub type domid_t = u16;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct mmu_update {
pub ptr: u64,
pub val: u64,
}
#[test]
fn bindgen_test_layout_mmu_update() {
assert_eq!(
::core::mem::size_of::<mmu_update>(),
16usize,
concat!("Size of: ", stringify!(mmu_update))
);
assert_eq!(
::core::mem::align_of::<mmu_update>(),
8usize,
concat!("Alignment of ", stringify!(mmu_update))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmu_update>())).ptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(mmu_update),
"::",
stringify!(ptr)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<mmu_update>())).val as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(mmu_update),
"::",
stringify!(val)
)
);
}
pub type mmu_update_t = mmu_update;
pub type __guest_handle_mmu_update_t = *mut mmu_update_t;
pub type __guest_handle_const_mmu_update_t = *const mmu_update_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct multicall_entry {
pub op: xen_ulong_t,
pub result: xen_ulong_t,
pub args: [xen_ulong_t; 6usize],
}
#[test]
fn bindgen_test_layout_multicall_entry() {
assert_eq!(
::core::mem::size_of::<multicall_entry>(),
64usize,
concat!("Size of: ", stringify!(multicall_entry))
);
assert_eq!(
::core::mem::align_of::<multicall_entry>(),
8usize,
concat!("Alignment of ", stringify!(multicall_entry))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<multicall_entry>())).op as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(multicall_entry),
"::",
stringify!(op)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<multicall_entry>())).result as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(multicall_entry),
"::",
stringify!(result)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<multicall_entry>())).args as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(multicall_entry),
"::",
stringify!(args)
)
);
}
pub type multicall_entry_t = multicall_entry;
pub type __guest_handle_multicall_entry_t = *mut multicall_entry_t;
pub type __guest_handle_const_multicall_entry_t = *const multicall_entry_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vcpu_time_info {
pub version: u32,
pub pad0: u32,
pub tsc_timestamp: u64,
pub system_time: u64,
pub tsc_to_system_mul: u32,
pub tsc_shift: i8,
pub pad1: [i8; 3usize],
}
#[test]
fn bindgen_test_layout_vcpu_time_info() {
assert_eq!(
::core::mem::size_of::<vcpu_time_info>(),
32usize,
concat!("Size of: ", stringify!(vcpu_time_info))
);
assert_eq!(
::core::mem::align_of::<vcpu_time_info>(),
8usize,
concat!("Alignment of ", stringify!(vcpu_time_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).version as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).pad0 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(pad0)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).tsc_timestamp as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(tsc_timestamp)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).system_time as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(system_time)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_time_info>())).tsc_to_system_mul as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(tsc_to_system_mul)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).tsc_shift as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(tsc_shift)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_time_info>())).pad1 as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(vcpu_time_info),
"::",
stringify!(pad1)
)
);
}
pub type vcpu_time_info_t = vcpu_time_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct vcpu_info {
pub evtchn_upcall_pending: u8,
pub evtchn_upcall_mask: u8,
pub evtchn_pending_sel: xen_ulong_t,
pub arch: arch_vcpu_info,
pub time: vcpu_time_info_t,
}
#[test]
fn bindgen_test_layout_vcpu_info() {
assert_eq!(
::core::mem::size_of::<vcpu_info>(),
64usize,
concat!("Size of: ", stringify!(vcpu_info))
);
assert_eq!(
::core::mem::align_of::<vcpu_info>(),
8usize,
concat!("Alignment of ", stringify!(vcpu_info))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<vcpu_info>())).evtchn_upcall_pending as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(vcpu_info),
"::",
stringify!(evtchn_upcall_pending)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_info>())).evtchn_upcall_mask as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(vcpu_info),
"::",
stringify!(evtchn_upcall_mask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_info>())).evtchn_pending_sel as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(vcpu_info),
"::",
stringify!(evtchn_pending_sel)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_info>())).arch as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(vcpu_info),
"::",
stringify!(arch)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<vcpu_info>())).time as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(vcpu_info),
"::",
stringify!(time)
)
);
}
pub type vcpu_info_t = vcpu_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct shared_info {
pub vcpu_info: [vcpu_info; 32usize],
pub evtchn_pending: [xen_ulong_t; 64usize],
pub evtchn_mask: [xen_ulong_t; 64usize],
pub wc_version: u32,
pub wc_sec: u32,
pub wc_nsec: u32,
pub wc_sec_hi: u32,
pub arch: arch_shared_info,
}
#[test]
fn bindgen_test_layout_shared_info() {
assert_eq!(
::core::mem::size_of::<shared_info>(),
3136usize,
concat!("Size of: ", stringify!(shared_info))
);
assert_eq!(
::core::mem::align_of::<shared_info>(),
8usize,
concat!("Alignment of ", stringify!(shared_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).vcpu_info as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(vcpu_info)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).evtchn_pending as *const _ as usize },
2048usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(evtchn_pending)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).evtchn_mask as *const _ as usize },
2560usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(evtchn_mask)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).wc_version as *const _ as usize },
3072usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(wc_version)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).wc_sec as *const _ as usize },
3076usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(wc_sec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).wc_nsec as *const _ as usize },
3080usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(wc_nsec)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).wc_sec_hi as *const _ as usize },
3084usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(wc_sec_hi)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<shared_info>())).arch as *const _ as usize },
3088usize,
concat!(
"Offset of field: ",
stringify!(shared_info),
"::",
stringify!(arch)
)
);
}
pub type shared_info_t = shared_info;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct start_info {
pub magic: [cty::c_char; 32usize],
pub nr_pages: cty::c_ulong,
pub shared_info: cty::c_ulong,
pub flags: u32,
pub store_mfn: xen_pfn_t,
pub store_evtchn: u32,
pub console: start_info__bindgen_ty_1,
pub pt_base: cty::c_ulong,
pub nr_pt_frames: cty::c_ulong,
pub mfn_list: cty::c_ulong,
pub mod_start: cty::c_ulong,
pub mod_len: cty::c_ulong,
pub cmd_line: [i8; 1024usize],
pub first_p2m_pfn: cty::c_ulong,
pub nr_p2m_frames: cty::c_ulong,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union start_info__bindgen_ty_1 {
pub domU: start_info__bindgen_ty_1__bindgen_ty_1,
pub dom0: start_info__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct start_info__bindgen_ty_1__bindgen_ty_1 {
pub mfn: xen_pfn_t,
pub evtchn: u32,
}
#[test]
fn bindgen_test_layout_start_info__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<start_info__bindgen_ty_1__bindgen_ty_1>(),
16usize,
concat!(
"Size of: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<start_info__bindgen_ty_1__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<start_info__bindgen_ty_1__bindgen_ty_1>())).mfn as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(mfn)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<start_info__bindgen_ty_1__bindgen_ty_1>())).evtchn as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(evtchn)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct start_info__bindgen_ty_1__bindgen_ty_2 {
pub info_off: u32,
pub info_size: u32,
}
#[test]
fn bindgen_test_layout_start_info__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<start_info__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Size of: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::core::mem::align_of::<start_info__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<start_info__bindgen_ty_1__bindgen_ty_2>())).info_off as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(info_off)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<start_info__bindgen_ty_1__bindgen_ty_2>())).info_size
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(info_size)
)
);
}
#[test]
fn bindgen_test_layout_start_info__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<start_info__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(start_info__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<start_info__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(start_info__bindgen_ty_1))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info__bindgen_ty_1>())).domU as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1),
"::",
stringify!(domU)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info__bindgen_ty_1>())).dom0 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(start_info__bindgen_ty_1),
"::",
stringify!(dom0)
)
);
}
#[test]
fn bindgen_test_layout_start_info() {
assert_eq!(
::core::mem::size_of::<start_info>(),
1168usize,
concat!("Size of: ", stringify!(start_info))
);
assert_eq!(
::core::mem::align_of::<start_info>(),
8usize,
concat!("Alignment of ", stringify!(start_info))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).magic as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(magic)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).nr_pages as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(nr_pages)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).shared_info as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(shared_info)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).flags as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).store_mfn as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(store_mfn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).store_evtchn as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(store_evtchn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).console as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(console)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).pt_base as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(pt_base)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).nr_pt_frames as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(nr_pt_frames)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).mfn_list as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(mfn_list)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).mod_start as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(mod_start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).mod_len as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(mod_len)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).cmd_line as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(cmd_line)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).first_p2m_pfn as *const _ as usize },
1152usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(first_p2m_pfn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<start_info>())).nr_p2m_frames as *const _ as usize },
1160usize,
concat!(
"Offset of field: ",
stringify!(start_info),
"::",
stringify!(nr_p2m_frames)
)
);
}
pub type start_info_t = start_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_multiboot_mod_list {
pub mod_start: u32,
pub mod_end: u32,
pub cmdline: u32,
pub pad: u32,
}
#[test]
fn bindgen_test_layout_xen_multiboot_mod_list() {
assert_eq!(
::core::mem::size_of::<xen_multiboot_mod_list>(),
16usize,
concat!("Size of: ", stringify!(xen_multiboot_mod_list))
);
assert_eq!(
::core::mem::align_of::<xen_multiboot_mod_list>(),
4usize,
concat!("Alignment of ", stringify!(xen_multiboot_mod_list))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<xen_multiboot_mod_list>())).mod_start as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(xen_multiboot_mod_list),
"::",
stringify!(mod_start)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).mod_end as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(xen_multiboot_mod_list),
"::",
stringify!(mod_end)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).cmdline as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(xen_multiboot_mod_list),
"::",
stringify!(cmdline)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_multiboot_mod_list>())).pad as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(xen_multiboot_mod_list),
"::",
stringify!(pad)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct dom0_vga_console_info {
pub video_type: u8,
pub u: dom0_vga_console_info__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union dom0_vga_console_info__bindgen_ty_1 {
pub text_mode_3: dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1,
pub vesa_lfb: dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1 {
pub font_height: u16,
pub cursor_x: u16,
pub cursor_y: u16,
pub rows: u16,
pub columns: u16,
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>(),
10usize,
concat!(
"Size of: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>()))
.font_height as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(font_height)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).cursor_x
as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(cursor_x)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).cursor_y
as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(cursor_y)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).rows
as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(rows)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1>())).columns
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(columns)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2 {
pub width: u16,
pub height: u16,
pub bytes_per_line: u16,
pub bits_per_pixel: u16,
pub lfb_base: u32,
pub lfb_size: u32,
pub red_pos: u8,
pub red_size: u8,
pub green_pos: u8,
pub green_size: u8,
pub blue_pos: u8,
pub blue_size: u8,
pub rsvd_pos: u8,
pub rsvd_size: u8,
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>(),
24usize,
concat!(
"Size of: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).width
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).height
as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
.bytes_per_line as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(bytes_per_line)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
.bits_per_pixel as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(bits_per_pixel)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).lfb_base
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(lfb_base)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).lfb_size
as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(lfb_size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).red_pos
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(red_pos)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).red_size
as *const _ as usize
},
17usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(red_size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).green_pos
as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(green_pos)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>()))
.green_size as *const _ as usize
},
19usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(green_size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).blue_pos
as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(blue_pos)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).blue_size
as *const _ as usize
},
21usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(blue_size)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).rsvd_pos
as *const _ as usize
},
22usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(rsvd_pos)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2>())).rsvd_size
as *const _ as usize
},
23usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(rsvd_size)
)
);
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<dom0_vga_console_info__bindgen_ty_1>(),
24usize,
concat!("Size of: ", stringify!(dom0_vga_console_info__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<dom0_vga_console_info__bindgen_ty_1>(),
4usize,
concat!(
"Alignment of ",
stringify!(dom0_vga_console_info__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1>())).text_mode_3 as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1),
"::",
stringify!(text_mode_3)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info__bindgen_ty_1>())).vesa_lfb as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info__bindgen_ty_1),
"::",
stringify!(vesa_lfb)
)
);
}
#[test]
fn bindgen_test_layout_dom0_vga_console_info() {
assert_eq!(
::core::mem::size_of::<dom0_vga_console_info>(),
28usize,
concat!("Size of: ", stringify!(dom0_vga_console_info))
);
assert_eq!(
::core::mem::align_of::<dom0_vga_console_info>(),
4usize,
concat!("Alignment of ", stringify!(dom0_vga_console_info))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<dom0_vga_console_info>())).video_type as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info),
"::",
stringify!(video_type)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<dom0_vga_console_info>())).u as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(dom0_vga_console_info),
"::",
stringify!(u)
)
);
}
pub type dom0_vga_console_info_t = dom0_vga_console_info;
pub type xen_domain_handle_t = [u8; 16usize];
pub type __guest_handle_uint8 = *mut u8;
pub type __guest_handle_const_uint8 = *const u8;
pub type __guest_handle_uint16 = *mut u16;
pub type __guest_handle_const_uint16 = *const u16;
pub type __guest_handle_uint32 = *mut u32;
pub type __guest_handle_const_uint32 = *const u32;
pub type __guest_handle_uint64 = *mut u64;
pub type __guest_handle_const_uint64 = *const u64;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xen_uuid_t {
pub a: [u8; 16usize],
}
#[test]
fn bindgen_test_layout_xen_uuid_t() {
assert_eq!(
::core::mem::size_of::<xen_uuid_t>(),
16usize,
concat!("Size of: ", stringify!(xen_uuid_t))
);
assert_eq!(
::core::mem::align_of::<xen_uuid_t>(),
1usize,
concat!("Alignment of ", stringify!(xen_uuid_t))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<xen_uuid_t>())).a as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xen_uuid_t),
"::",
stringify!(a)
)
);
}
pub type evtchn_port_t = u32;
pub type __guest_handle_evtchn_port_t = *mut evtchn_port_t;
pub type __guest_handle_const_evtchn_port_t = *const evtchn_port_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_alloc_unbound {
pub dom: domid_t,
pub remote_dom: domid_t,
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_alloc_unbound() {
assert_eq!(
::core::mem::size_of::<evtchn_alloc_unbound>(),
8usize,
concat!("Size of: ", stringify!(evtchn_alloc_unbound))
);
assert_eq!(
::core::mem::align_of::<evtchn_alloc_unbound>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_alloc_unbound))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_alloc_unbound>())).dom as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_alloc_unbound),
"::",
stringify!(dom)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_alloc_unbound>())).remote_dom as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(evtchn_alloc_unbound),
"::",
stringify!(remote_dom)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_alloc_unbound>())).port as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_alloc_unbound),
"::",
stringify!(port)
)
);
}
pub type evtchn_alloc_unbound_t = evtchn_alloc_unbound;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_interdomain {
pub remote_dom: domid_t,
pub remote_port: evtchn_port_t,
pub local_port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_interdomain() {
assert_eq!(
::core::mem::size_of::<evtchn_bind_interdomain>(),
12usize,
concat!("Size of: ", stringify!(evtchn_bind_interdomain))
);
assert_eq!(
::core::mem::align_of::<evtchn_bind_interdomain>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_bind_interdomain))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_bind_interdomain>())).remote_dom as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_interdomain),
"::",
stringify!(remote_dom)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_bind_interdomain>())).remote_port as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_interdomain),
"::",
stringify!(remote_port)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_bind_interdomain>())).local_port as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_interdomain),
"::",
stringify!(local_port)
)
);
}
pub type evtchn_bind_interdomain_t = evtchn_bind_interdomain;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_virq {
pub virq: u32,
pub vcpu: u32,
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_virq() {
assert_eq!(
::core::mem::size_of::<evtchn_bind_virq>(),
12usize,
concat!("Size of: ", stringify!(evtchn_bind_virq))
);
assert_eq!(
::core::mem::align_of::<evtchn_bind_virq>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_bind_virq))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).virq as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_virq),
"::",
stringify!(virq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).vcpu as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_virq),
"::",
stringify!(vcpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_virq>())).port as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_virq),
"::",
stringify!(port)
)
);
}
pub type evtchn_bind_virq_t = evtchn_bind_virq;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_pirq {
pub pirq: u32,
pub flags: u32,
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_pirq() {
assert_eq!(
::core::mem::size_of::<evtchn_bind_pirq>(),
12usize,
concat!("Size of: ", stringify!(evtchn_bind_pirq))
);
assert_eq!(
::core::mem::align_of::<evtchn_bind_pirq>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_bind_pirq))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).pirq as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_pirq),
"::",
stringify!(pirq)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_pirq),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_pirq>())).port as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_pirq),
"::",
stringify!(port)
)
);
}
pub type evtchn_bind_pirq_t = evtchn_bind_pirq;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_ipi {
pub vcpu: u32,
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_bind_ipi() {
assert_eq!(
::core::mem::size_of::<evtchn_bind_ipi>(),
8usize,
concat!("Size of: ", stringify!(evtchn_bind_ipi))
);
assert_eq!(
::core::mem::align_of::<evtchn_bind_ipi>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_bind_ipi))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_ipi>())).vcpu as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_ipi),
"::",
stringify!(vcpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_ipi>())).port as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_ipi),
"::",
stringify!(port)
)
);
}
pub type evtchn_bind_ipi_t = evtchn_bind_ipi;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_close {
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_close() {
assert_eq!(
::core::mem::size_of::<evtchn_close>(),
4usize,
concat!("Size of: ", stringify!(evtchn_close))
);
assert_eq!(
::core::mem::align_of::<evtchn_close>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_close))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_close>())).port as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_close),
"::",
stringify!(port)
)
);
}
pub type evtchn_close_t = evtchn_close;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_send {
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_send() {
assert_eq!(
::core::mem::size_of::<evtchn_send>(),
4usize,
concat!("Size of: ", stringify!(evtchn_send))
);
assert_eq!(
::core::mem::align_of::<evtchn_send>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_send))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_send>())).port as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_send),
"::",
stringify!(port)
)
);
}
pub type evtchn_send_t = evtchn_send;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct evtchn_status {
pub dom: domid_t,
pub port: evtchn_port_t,
pub status: u32,
pub vcpu: u32,
pub u: evtchn_status__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union evtchn_status__bindgen_ty_1 {
pub unbound: evtchn_status__bindgen_ty_1__bindgen_ty_1,
pub interdomain: evtchn_status__bindgen_ty_1__bindgen_ty_2,
pub pirq: u32,
pub virq: u32,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_status__bindgen_ty_1__bindgen_ty_1 {
pub dom: domid_t,
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<evtchn_status__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Size of: ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
::core::mem::align_of::<evtchn_status__bindgen_ty_1__bindgen_ty_1>(),
2usize,
concat!(
"Alignment of ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_1>())).dom as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_1),
"::",
stringify!(dom)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_status__bindgen_ty_1__bindgen_ty_2 {
pub dom: domid_t,
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1__bindgen_ty_2() {
assert_eq!(
::core::mem::size_of::<evtchn_status__bindgen_ty_1__bindgen_ty_2>(),
8usize,
concat!(
"Size of: ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
::core::mem::align_of::<evtchn_status__bindgen_ty_1__bindgen_ty_2>(),
4usize,
concat!(
"Alignment of ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_2>())).dom as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(dom)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1__bindgen_ty_2>())).port as *const _
as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1__bindgen_ty_2),
"::",
stringify!(port)
)
);
}
#[test]
fn bindgen_test_layout_evtchn_status__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<evtchn_status__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(evtchn_status__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<evtchn_status__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_status__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).unbound as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1),
"::",
stringify!(unbound)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).interdomain as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1),
"::",
stringify!(interdomain)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).pirq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1),
"::",
stringify!(pirq)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_status__bindgen_ty_1>())).virq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status__bindgen_ty_1),
"::",
stringify!(virq)
)
);
}
#[test]
fn bindgen_test_layout_evtchn_status() {
assert_eq!(
::core::mem::size_of::<evtchn_status>(),
24usize,
concat!("Size of: ", stringify!(evtchn_status))
);
assert_eq!(
::core::mem::align_of::<evtchn_status>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_status))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_status>())).dom as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status),
"::",
stringify!(dom)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_status>())).port as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_status>())).status as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_status>())).vcpu as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status),
"::",
stringify!(vcpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_status>())).u as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(evtchn_status),
"::",
stringify!(u)
)
);
}
pub type evtchn_status_t = evtchn_status;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_bind_vcpu {
pub port: evtchn_port_t,
pub vcpu: u32,
}
#[test]
fn bindgen_test_layout_evtchn_bind_vcpu() {
assert_eq!(
::core::mem::size_of::<evtchn_bind_vcpu>(),
8usize,
concat!("Size of: ", stringify!(evtchn_bind_vcpu))
);
assert_eq!(
::core::mem::align_of::<evtchn_bind_vcpu>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_bind_vcpu))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_vcpu>())).port as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_vcpu),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_bind_vcpu>())).vcpu as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_bind_vcpu),
"::",
stringify!(vcpu)
)
);
}
pub type evtchn_bind_vcpu_t = evtchn_bind_vcpu;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_unmask {
pub port: evtchn_port_t,
}
#[test]
fn bindgen_test_layout_evtchn_unmask() {
assert_eq!(
::core::mem::size_of::<evtchn_unmask>(),
4usize,
concat!("Size of: ", stringify!(evtchn_unmask))
);
assert_eq!(
::core::mem::align_of::<evtchn_unmask>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_unmask))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_unmask>())).port as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_unmask),
"::",
stringify!(port)
)
);
}
pub type evtchn_unmask_t = evtchn_unmask;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_reset {
pub dom: domid_t,
}
#[test]
fn bindgen_test_layout_evtchn_reset() {
assert_eq!(
::core::mem::size_of::<evtchn_reset>(),
2usize,
concat!("Size of: ", stringify!(evtchn_reset))
);
assert_eq!(
::core::mem::align_of::<evtchn_reset>(),
2usize,
concat!("Alignment of ", stringify!(evtchn_reset))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_reset>())).dom as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_reset),
"::",
stringify!(dom)
)
);
}
pub type evtchn_reset_t = evtchn_reset;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_init_control {
pub control_gfn: u64,
pub offset: u32,
pub vcpu: u32,
pub link_bits: u8,
pub _pad: [u8; 7usize],
}
#[test]
fn bindgen_test_layout_evtchn_init_control() {
assert_eq!(
::core::mem::size_of::<evtchn_init_control>(),
24usize,
concat!("Size of: ", stringify!(evtchn_init_control))
);
assert_eq!(
::core::mem::align_of::<evtchn_init_control>(),
8usize,
concat!("Alignment of ", stringify!(evtchn_init_control))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_init_control>())).control_gfn as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_init_control),
"::",
stringify!(control_gfn)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_init_control),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).vcpu as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(evtchn_init_control),
"::",
stringify!(vcpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_init_control>())).link_bits as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(evtchn_init_control),
"::",
stringify!(link_bits)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_init_control>()))._pad as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(evtchn_init_control),
"::",
stringify!(_pad)
)
);
}
pub type evtchn_init_control_t = evtchn_init_control;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_expand_array {
pub array_gfn: u64,
}
#[test]
fn bindgen_test_layout_evtchn_expand_array() {
assert_eq!(
::core::mem::size_of::<evtchn_expand_array>(),
8usize,
concat!("Size of: ", stringify!(evtchn_expand_array))
);
assert_eq!(
::core::mem::align_of::<evtchn_expand_array>(),
8usize,
concat!("Alignment of ", stringify!(evtchn_expand_array))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_expand_array>())).array_gfn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_expand_array),
"::",
stringify!(array_gfn)
)
);
}
pub type evtchn_expand_array_t = evtchn_expand_array;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_set_priority {
pub port: evtchn_port_t,
pub priority: u32,
}
#[test]
fn bindgen_test_layout_evtchn_set_priority() {
assert_eq!(
::core::mem::size_of::<evtchn_set_priority>(),
8usize,
concat!("Size of: ", stringify!(evtchn_set_priority))
);
assert_eq!(
::core::mem::align_of::<evtchn_set_priority>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_set_priority))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_set_priority>())).port as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_set_priority),
"::",
stringify!(port)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_set_priority>())).priority as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_set_priority),
"::",
stringify!(priority)
)
);
}
pub type evtchn_set_priority_t = evtchn_set_priority;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct evtchn_op {
pub cmd: u32,
pub u: evtchn_op__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union evtchn_op__bindgen_ty_1 {
pub alloc_unbound: evtchn_alloc_unbound_t,
pub bind_interdomain: evtchn_bind_interdomain_t,
pub bind_virq: evtchn_bind_virq_t,
pub bind_pirq: evtchn_bind_pirq_t,
pub bind_ipi: evtchn_bind_ipi_t,
pub close: evtchn_close_t,
pub send: evtchn_send_t,
pub status: evtchn_status_t,
pub bind_vcpu: evtchn_bind_vcpu_t,
pub unmask: evtchn_unmask_t,
}
#[test]
fn bindgen_test_layout_evtchn_op__bindgen_ty_1() {
assert_eq!(
::core::mem::size_of::<evtchn_op__bindgen_ty_1>(),
24usize,
concat!("Size of: ", stringify!(evtchn_op__bindgen_ty_1))
);
assert_eq!(
::core::mem::align_of::<evtchn_op__bindgen_ty_1>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_op__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).alloc_unbound as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(alloc_unbound)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_interdomain as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(bind_interdomain)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_virq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(bind_virq)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_pirq as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(bind_pirq)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_ipi as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(bind_ipi)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).close as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(close)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).send as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(send)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).status as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).bind_vcpu as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(bind_vcpu)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op__bindgen_ty_1>())).unmask as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op__bindgen_ty_1),
"::",
stringify!(unmask)
)
);
}
#[test]
fn bindgen_test_layout_evtchn_op() {
assert_eq!(
::core::mem::size_of::<evtchn_op>(),
28usize,
concat!("Size of: ", stringify!(evtchn_op))
);
assert_eq!(
::core::mem::align_of::<evtchn_op>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_op))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op>())).cmd as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op),
"::",
stringify!(cmd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_op>())).u as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_op),
"::",
stringify!(u)
)
);
}
pub type evtchn_op_t = evtchn_op;
pub type __guest_handle_evtchn_op_t = *mut evtchn_op_t;
pub type __guest_handle_const_evtchn_op_t = *const evtchn_op_t;
pub type event_word_t = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct evtchn_fifo_control_block {
pub ready: u32,
pub _rsvd: u32,
pub head: [u32; 16usize],
}
#[test]
fn bindgen_test_layout_evtchn_fifo_control_block() {
assert_eq!(
::core::mem::size_of::<evtchn_fifo_control_block>(),
72usize,
concat!("Size of: ", stringify!(evtchn_fifo_control_block))
);
assert_eq!(
::core::mem::align_of::<evtchn_fifo_control_block>(),
4usize,
concat!("Alignment of ", stringify!(evtchn_fifo_control_block))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_fifo_control_block>())).ready as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(evtchn_fifo_control_block),
"::",
stringify!(ready)
)
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<evtchn_fifo_control_block>()))._rsvd as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(evtchn_fifo_control_block),
"::",
stringify!(_rsvd)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<evtchn_fifo_control_block>())).head as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(evtchn_fifo_control_block),
"::",
stringify!(head)
)
);
}
pub type evtchn_fifo_control_block_t = evtchn_fifo_control_block;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_shutdown {
pub reason: cty::c_uint,
}
#[test]
fn bindgen_test_layout_sched_shutdown() {
assert_eq!(
::core::mem::size_of::<sched_shutdown>(),
4usize,
concat!("Size of: ", stringify!(sched_shutdown))
);
assert_eq!(
::core::mem::align_of::<sched_shutdown>(),
4usize,
concat!("Alignment of ", stringify!(sched_shutdown))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_shutdown>())).reason as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sched_shutdown),
"::",
stringify!(reason)
)
);
}
pub type sched_shutdown_t = sched_shutdown;
pub type __guest_handle_sched_shutdown_t = *mut sched_shutdown_t;
pub type __guest_handle_const_sched_shutdown_t = *const sched_shutdown_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_poll {
pub ports: __guest_handle_evtchn_port_t,
pub nr_ports: cty::c_uint,
pub timeout: u64,
}
#[test]
fn bindgen_test_layout_sched_poll() {
assert_eq!(
::core::mem::size_of::<sched_poll>(),
24usize,
concat!("Size of: ", stringify!(sched_poll))
);
assert_eq!(
::core::mem::align_of::<sched_poll>(),
8usize,
concat!("Alignment of ", stringify!(sched_poll))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_poll>())).ports as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sched_poll),
"::",
stringify!(ports)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_poll>())).nr_ports as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sched_poll),
"::",
stringify!(nr_ports)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_poll>())).timeout as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sched_poll),
"::",
stringify!(timeout)
)
);
}
pub type sched_poll_t = sched_poll;
pub type __guest_handle_sched_poll_t = *mut sched_poll_t;
pub type __guest_handle_const_sched_poll_t = *const sched_poll_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_remote_shutdown {
pub domain_id: domid_t,
pub reason: cty::c_uint,
}
#[test]
fn bindgen_test_layout_sched_remote_shutdown() {
assert_eq!(
::core::mem::size_of::<sched_remote_shutdown>(),
8usize,
concat!("Size of: ", stringify!(sched_remote_shutdown))
);
assert_eq!(
::core::mem::align_of::<sched_remote_shutdown>(),
4usize,
concat!("Alignment of ", stringify!(sched_remote_shutdown))
);
assert_eq!(
unsafe {
&(*(::core::ptr::null::<sched_remote_shutdown>())).domain_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sched_remote_shutdown),
"::",
stringify!(domain_id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_remote_shutdown>())).reason as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sched_remote_shutdown),
"::",
stringify!(reason)
)
);
}
pub type sched_remote_shutdown_t = sched_remote_shutdown;
pub type __guest_handle_sched_remote_shutdown_t = *mut sched_remote_shutdown_t;
pub type __guest_handle_const_sched_remote_shutdown_t = *const sched_remote_shutdown_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_watchdog {
pub id: u32,
pub timeout: u32,
}
#[test]
fn bindgen_test_layout_sched_watchdog() {
assert_eq!(
::core::mem::size_of::<sched_watchdog>(),
8usize,
concat!("Size of: ", stringify!(sched_watchdog))
);
assert_eq!(
::core::mem::align_of::<sched_watchdog>(),
4usize,
concat!("Alignment of ", stringify!(sched_watchdog))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_watchdog>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sched_watchdog),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_watchdog>())).timeout as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(sched_watchdog),
"::",
stringify!(timeout)
)
);
}
pub type sched_watchdog_t = sched_watchdog;
pub type __guest_handle_sched_watchdog_t = *mut sched_watchdog_t;
pub type __guest_handle_const_sched_watchdog_t = *const sched_watchdog_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sched_pin_override {
pub pcpu: i32,
}
#[test]
fn bindgen_test_layout_sched_pin_override() {
assert_eq!(
::core::mem::size_of::<sched_pin_override>(),
4usize,
concat!("Size of: ", stringify!(sched_pin_override))
);
assert_eq!(
::core::mem::align_of::<sched_pin_override>(),
4usize,
concat!("Alignment of ", stringify!(sched_pin_override))
);
assert_eq!(
unsafe { &(*(::core::ptr::null::<sched_pin_override>())).pcpu as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sched_pin_override),
"::",
stringify!(pcpu)
)
);
}
pub type sched_pin_override_t = sched_pin_override;
pub type __guest_handle_sched_pin_override_t = *mut sched_pin_override_t;
pub type __guest_handle_const_sched_pin_override_t = *const sched_pin_override_t;