diff --git a/tools/hermit_proxy/.gitignore b/tools/hermit_proxy/.gitignore new file mode 100644 index 000000000..eb5a316cb --- /dev/null +++ b/tools/hermit_proxy/.gitignore @@ -0,0 +1 @@ +target diff --git a/tools/hermit_proxy/Cargo.lock b/tools/hermit_proxy/Cargo.lock new file mode 100644 index 000000000..036f5057b --- /dev/null +++ b/tools/hermit_proxy/Cargo.lock @@ -0,0 +1,216 @@ +[root] +name = "hermitcore_proxy" +version = "0.0.1" +dependencies = [ + "byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)", + "elf 0.0.10 (registry+https://github.com/rust-lang/crates.io-index)", + "env_logger 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)", + "errno 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)", + "inotify 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", + "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", + "memmap 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)", + "nix 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "aho-corasick" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "bitflags" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "byteorder" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "byteorder" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "cfg-if" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "elf" +version = "0.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "env_logger" +version = "0.3.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)", + "regex 0.1.80 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "errno" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "fs2" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "inotify" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "kernel32-sys" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "libc" +version = "0.2.22" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "log" +version = "0.3.7" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "memchr" +version = "0.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "memmap" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "fs2 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)", + "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", + "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "nix" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)", + "cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", + "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "regex" +version = "0.1.80" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "aho-corasick 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)", + "memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)", + "regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)", + "thread_local 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)", + "utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "regex-syntax" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "thread-id" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)", + "libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "thread_local" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +dependencies = [ + "thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)", +] + +[[package]] +name = "utf8-ranges" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "void" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "winapi" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[[package]] +name = "winapi-build" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" + +[metadata] +"checksum aho-corasick 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ca972c2ea5f742bfce5687b9aef75506a764f61d37f8f649047846a9686ddb66" +"checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d" +"checksum byteorder 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0fc10e8cc6b2580fda3f36eb6dc5316657f812a3df879a44a66fc9f0fdbc4855" +"checksum byteorder 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c40977b0ee6b9885c9013cd41d9feffdd22deb3bb4dc3a71d901cc7a77de18c8" +"checksum cfg-if 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "de1e760d7b6535af4241fca8bd8adf68e2e7edacc6b29f5d399050c5e48cf88c" +"checksum elf 0.0.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4841de15dbe0e49b9b62a417589299e3be0d557e0900d36acb87e6dae47197f5" +"checksum env_logger 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "15abd780e45b3ea4f76b4e9a26ff4843258dd8a3eed2775a0e7368c2e7936c2f" +"checksum errno 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b2c858c42ac0b88532f48fca88b0ed947cad4f1f64d904bcd6c9f138f7b95d70" +"checksum fs2 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "34edaee07555859dc13ca387e6ae05686bb4d0364c95d649b6dab959511f4baf" +"checksum inotify 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "887fcc180136e77a85e6a6128579a719027b1bab9b1c38ea4444244fe262c20c" +"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d" +"checksum libc 0.2.22 (registry+https://github.com/rust-lang/crates.io-index)" = "babb8281da88cba992fa1f4ddec7d63ed96280a1a53ec9b919fd37b53d71e502" +"checksum log 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "5141eca02775a762cc6cd564d8d2c50f67c0ea3a372cbf1c51592b3e029e10ad" +"checksum memchr 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "d8b629fb514376c675b98c1421e80b151d3817ac42d7c667717d282761418d20" +"checksum memmap 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "46f3c7359028b31999287dae4e5047ddfe90a23b7dca2282ce759b491080c99b" +"checksum nix 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "47e49f6982987135c5e9620ab317623e723bd06738fd85377e8d55f57c8b6487" +"checksum regex 0.1.80 (registry+https://github.com/rust-lang/crates.io-index)" = "4fd4ace6a8cf7860714a2c2280d6c1f7e6a413486c13298bbc86fd3da019402f" +"checksum regex-syntax 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957" +"checksum thread-id 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a9539db560102d1cef46b8b78ce737ff0bb64e7e18d35b2a5688f7d097d0ff03" +"checksum thread_local 0.2.7 (registry+https://github.com/rust-lang/crates.io-index)" = "8576dbbfcaef9641452d5cf0df9b0e7eeab7694956dd33bb61515fb8f18cfdd5" +"checksum utf8-ranges 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "a1ca13c08c41c9c3e04224ed9ff80461d97e121589ff27c753a16cb10830ae0f" +"checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" +"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a" +"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc" diff --git a/tools/hermit_proxy/Cargo.toml b/tools/hermit_proxy/Cargo.toml new file mode 100644 index 000000000..be80a4004 --- /dev/null +++ b/tools/hermit_proxy/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "hermitcore_proxy" +version = "0.0.1" +authors = ["bytesnake "] + +[dependencies] +libc = "0.2.21" +nix = "0.8.0" +memmap = "0.5.2" +elf = "0.0.10" +errno = "0.2.3" +inotify = "0.3" +byteorder = "1" +log = "0.3" +env_logger = "0.3" diff --git a/tools/hermit_proxy/src/dedicate/mod.rs b/tools/hermit_proxy/src/dedicate/mod.rs new file mode 100644 index 000000000..683c2c7a2 --- /dev/null +++ b/tools/hermit_proxy/src/dedicate/mod.rs @@ -0,0 +1,4 @@ +pub mod qemu; +pub mod multi; +pub mod proto; +pub mod socket; diff --git a/tools/hermit_proxy/src/dedicate/multi.rs b/tools/hermit_proxy/src/dedicate/multi.rs new file mode 100644 index 000000000..2da510a09 --- /dev/null +++ b/tools/hermit_proxy/src/dedicate/multi.rs @@ -0,0 +1,48 @@ +use std::fs::File; +use std::env; +use std::io::{Write, Read}; + +use error::*; + +use hermit_env; +use dedicate::socket::Socket; + +pub struct Multi { + num: u8, + socket: Socket +} + +impl Multi { + pub fn new(num: u8, path: &str) -> Result { + // request a new isle, enforce close + { + let mut path_file = File::create(format!("/sys/hermit/isle{}/path", num)).map_err(|_| Error::InvalidFile)?; + let mut cpus_file = File::create(format!("/sys/hermit/isle{}/cpus", num)).map_err(|_| Error::InvalidFile)?; + + let cpus = hermit_env::num_cpus(); + + path_file.write_all(path.as_bytes()).map_err(|_| Error::InvalidFile)?; + cpus_file.write_all(cpus.as_bytes()).map_err(|_| Error::InvalidFile)?; + } + + // check the result + let mut path_file = File::create(format!("/sys/hermit/isle{}/cpus", num)).map_err(|_| Error::InvalidFile)?; + let mut result = String::new(); + + path_file.read_to_string(&mut result).map_err(|_| Error::InvalidFile)?; + + if result.parse::().map_err(|_| Error::InvalidFile)? == -1 { + return Err(Error::MultiIsleFailed); + } + + Ok(Multi { num: num, socket: Socket::new_multi(num) }) + } + + pub fn get_num(&self) -> u8 { + self.num + } + + pub fn run(&self) { + self.socket.connect().run(); + } +} diff --git a/tools/hermit_proxy/src/dedicate/proto.rs b/tools/hermit_proxy/src/dedicate/proto.rs new file mode 100644 index 000000000..3adc6fff9 --- /dev/null +++ b/tools/hermit_proxy/src/dedicate/proto.rs @@ -0,0 +1,139 @@ +use std::io::{Read, Seek, Cursor}; +use std::mem; +use byteorder::{ReadBytesExt, WriteBytesExt,LittleEndian,BigEndian}; +use std::ffi::CString; + +const PACKET_LENGTH: &'static [u64] = &[1,3,1,1,2,3]; + +#[derive(Debug)] +pub enum PartialPacket { + Exit { arg: i32 }, + Write { fd: i32, len: u64 }, + Open { len: i64 }, + Close { fd: i32 }, + Read { fd: i32, len: u64 }, + LSeek { fd: i32, offset: i64, whence: i32 } +} + +impl PartialPacket { + pub fn from_buf(id: i32, buf: &mut Cursor>) -> PartialPacket { + match id { + 0 => PartialPacket::Exit { + arg: buf.read_i32::().unwrap() + }, + 1 => PartialPacket::Write { + fd: buf.read_i32::().unwrap(), + len: buf.read_u64::().unwrap() + }, + 2 => PartialPacket::Open { + len: buf.read_i64::().unwrap() + }, + 3 => PartialPacket::Close { + fd: buf.read_i32::().unwrap() + }, + 4 => PartialPacket::Read { + fd: buf.read_i32::().unwrap(), + len: buf.read_u64::().unwrap() + }, + 5 => PartialPacket::LSeek { + fd: buf.read_i32::().unwrap(), + offset: buf.read_i64::().unwrap(), + whence: buf.read_i32::().unwrap() + }, + _ => panic!("") + } + } + + pub fn additional_size(&self) -> usize { + match *self { + PartialPacket::Write { fd, len } => len as usize, + PartialPacket::Open { len } => len as usize + 8, + _ => 0 + } + } +} + +#[derive(Debug)] +pub enum Packet { + Exit { arg: i32 }, + Write { fd: i32, buf: Vec }, + Open { name: CString, flags: i32, mode: i32 }, + Close { fd: i32 }, + Read { fd: i32, len: u64 }, + LSeek { fd: i32, whence: i32, offset: i64 } +} + +impl Packet { + pub fn from_buf(obj: &PartialPacket, buf: &mut Cursor>) -> Packet { + match *obj { + PartialPacket::Write { fd, len } => { + debug!("Read write packet with length {}", len); + let mut content = vec![0; len as usize]; + buf.read(&mut content); + + Packet::Write { fd: fd, buf: content } + }, + PartialPacket::Open { len } => { + let mut name_buf = vec![0; len as usize]; + buf.read(&mut name_buf); + name_buf.pop(); + + let c_str = CString::new(name_buf).unwrap(); + + Packet::Open { + name: c_str, + flags: buf.read_i32::().unwrap(), + mode: buf.read_i32::().unwrap() + } + }, + PartialPacket::Exit { arg } => Packet::Exit { arg }, + PartialPacket::Close { fd } => Packet::Close { fd }, + PartialPacket::Read { fd, len } => Packet::Read { fd, len }, + PartialPacket::LSeek { fd, whence, offset } => Packet::LSeek { fd, whence, offset } + } + } +} + +#[derive(Debug)] +pub enum State { + Id, + Type { id: i32, len: u64 }, + Partial(PartialPacket), + Finished(Packet) +} + +impl State { + pub fn read_in(self, buf: &mut Cursor>) -> State { + let length = buf.get_ref().len() - buf.position() as usize; + + match self { + State::Id if length < mem::size_of::() => { + State::Id + }, + State::Id => { + let id = buf.read_i32::().unwrap(); + State::Type { + id: id, + len: match id as usize { + x @ 0...5 => PACKET_LENGTH[x], + _ => panic!("") + } + } + }, + State::Type { id, len } => { + if length >= (len as usize) * mem::size_of::() { + let par_packet = State::Partial(PartialPacket::from_buf(id, buf)); + debug!("Partial packet {:?} pos {}", par_packet, buf.position()); + + par_packet + } else { + self + } + }, + State::Partial(ref packet) if length >= packet.additional_size() => { + State::Finished(Packet::from_buf(packet, buf)) + }, + _ => { self } + } + } +} diff --git a/tools/hermit_proxy/src/dedicate/qemu.rs b/tools/hermit_proxy/src/dedicate/qemu.rs new file mode 100644 index 000000000..fa91f181d --- /dev/null +++ b/tools/hermit_proxy/src/dedicate/qemu.rs @@ -0,0 +1,134 @@ +use std::env; +use utils; +use error::*; +use std::process::{Stdio, Child, Command}; +use libc; +use std::fs::File; +use std::io::Read; + +use hermit_env; +use dedicate::socket::Socket; + +const PIDNAME: &'static str = "/tmp/hpid-XXXXXX"; +const TMPNAME: &'static str = "/tmp/hermit-XXXXXX"; + +#[derive(Debug)] +pub struct QEmu { + socket: Socket, + child: Child, + tmp_file: String, + pid_file: String, +} + +impl QEmu { + pub fn new(path: &str) -> Result { + let tmpf = utils::create_tmp_file(TMPNAME)?; + let pidf = utils::create_tmp_file(PIDNAME)?; + + let mut child = QEmu::start_with(path, &tmpf, &pidf)?.spawn().expect("Couldn't find qemu binary!"); + + Ok(QEmu { + socket: Socket::new_qemu(), + child: child, + tmp_file: tmpf, + pid_file: pidf + }) + } + + pub fn run(&self) { + self.socket.connect().run(); + } + + pub fn tmp_path(&self) -> &str { + &self.tmp_file + } + + pub fn start_with(path: &str, tmp_file: &str, pid_file: &str) -> Result { + let hostfwd = format!("user,hostfwd=tcp:127.0.0.1:{}-:{}", hermit_env::port(), hermit_env::port()); + let monitor_str = format!("telnet:127.0.0.1:{},server,nowait", (hermit_env::port().parse::().unwrap()+1).to_string()); + let chardev = format!("file,id=gnc0,path={}",&tmp_file); + let freq = format!("\"-freq{} -proxy\"",(utils::cpufreq().unwrap()/1000).to_string()); + let cpus = hermit_env::num_cpus(); + let mem_size = hermit_env::mem_size(); + + let exe = env::current_exe().unwrap(); + let name = exe.to_str().unwrap(); + let exe_path = name.split("/").take(name.matches('/').count()).collect::>().join("/"); + + let exe = format!("{}/ldhermit.elf", exe_path); + + let mut port_str; + + let mut args: Vec<&str> = vec![ + "-daemonize", + "-display", "none", + "-smp", &cpus, + "-m", &mem_size, + "-pidfile", pid_file, + "-net", "nic,model=rtl8139", + "-net", &hostfwd, + "-chardev", &chardev, + "-device", "pci-serial,chardev=gnc0", + "-kernel", &exe, + "-initrd", path, + "-append", &freq]; + + let app_port = hermit_env::app_port(); + if app_port != "" { + port_str = format!("tcp:{}::{}", app_port, app_port); + args.push("-redir"); + args.push(&port_str); + } + + if hermit_env::use_kvm() != "0" { + args.push("-machine"); + args.push("accel=kvm"); + args.push("-cpu"); + args.push("host"); + } + + if hermit_env::monitor() != "0" { + args.push("-monitor"); + args.push(&monitor_str); + } + + if hermit_env::should_debug() != "0" { + args.push("-s"); + } + + if hermit_env::capture_net() != "0" { + args.push("-net"); + args.push("dump"); + } + + if hermit_env::verbose() != "0" { + println!("{:#?}", args); + } + + debug!("Execute {} with args {:#?}", hermit_env::qemu_binary(), args); + + let mut cmd = Command::new(hermit_env::qemu_binary()); + + cmd.args(args).stdout(Stdio::piped()).stderr(Stdio::piped()); + + Ok(cmd) + } +} + +impl Drop for QEmu { + fn drop(&mut self) { + let mut id_str = String::new(); + let mut file = File::open(&self.pid_file).unwrap(); + file.read_to_string(&mut id_str); + id_str.pop(); + + let id = id_str.parse::().unwrap(); + + if id >= 0 { + unsafe { libc::kill(id, libc::SIGINT); } + } + + utils::delete_tmp_file(&self.pid_file); + utils::delete_tmp_file(&self.tmp_file); + } +} diff --git a/tools/hermit_proxy/src/dedicate/socket.rs b/tools/hermit_proxy/src/dedicate/socket.rs new file mode 100644 index 000000000..5e11b368e --- /dev/null +++ b/tools/hermit_proxy/src/dedicate/socket.rs @@ -0,0 +1,151 @@ +use std::net::TcpStream; +use std::env; +use std::mem::transmute; +use std::io::{Write, Read, Cursor}; +use std::ffi::CString; +use std::process; +use byteorder::{ReadBytesExt, WriteBytesExt, LittleEndian}; + +use dedicate::proto; +use dedicate::proto::Packet; + +use libc; + +const HERMIT_MAGIC: u32 = 0x7E317; + +#[derive(Debug)] +pub enum Socket { + QEmu, + Multi(u8), + Connected { stream: TcpStream } +} + +impl Socket { + pub fn new_qemu() -> Socket { + Socket::QEmu + } + + pub fn new_multi(id: u8) -> Socket { + Socket::Multi(id) + } + + pub fn connect(&self) -> Socket { + let mut stream = match *self { + Socket::QEmu => TcpStream::connect(("127.0.0.1", 0x494E)).unwrap(), + Socket::Multi(id) => TcpStream::connect((format!("127.0.0.{}", id).as_ref(), 0x494E)).unwrap(), + _ => panic!("") + }; + + debug!("Connected to {}", stream.peer_addr().unwrap()); + + let length: usize = 4 + env::args().skip(1).map(|x| 4+x.len()).sum::()+ 4 + env::vars().map(|(x,y)| 5 + x.len()+ y.len()).sum::(); + + let mut buf = Cursor::new(vec![0u8;length]); + buf.write_u32::(HERMIT_MAGIC); + + // send all arguments (skip first) + buf.write_u32::(env::args().count() as u32 - 1); + for key in env::args().skip(1) { + buf.write_u32::(key.len() as u32); + buf.write(key.as_bytes()); + } + + // send the environment + buf.write_u32::(env::vars().count() as u32); + for (val,key) in env::vars() { + let tmp = format!("{}={}", val, key); + buf.write_u32::(tmp.len() as u32); + buf.write(tmp.as_bytes()); + } + + stream.write(buf.get_ref()); + + debug!("Transmitted environment and arguments with length {}", length); + + Socket::Connected { stream: stream } + } + + pub fn run(&mut self) { + debug!("Initializing protocol state machine"); + let mut state = proto::State::Id; + let mut stream = match self { + &mut Socket::Connected { ref mut stream } => stream, + _ => return + }; + + let mut cur = Cursor::new(vec![]); + let mut buf = [0u8; 4096]; + 'main: loop { + debug!("Attempt read"); + let nread = stream.read(&mut buf).unwrap(); + + let old_position = cur.position(); + let end = cur.get_ref().len() as u64; + + cur.set_position(end); + cur.write(&buf[0..nread]); + cur.set_position(old_position); + + debug!("Got message with {} bytes: {:?}", nread, &buf[0 .. nread]); + + let mut old_position = cur.position(); + + loop { + state = state.read_in(&mut cur); + + if let proto::State::Finished(packet) = state { + unsafe { + match packet { + Packet::Exit { arg } => break 'main, + Packet::Write { fd, buf } => { + let buf_ret: [u8;8] = transmute(libc::write(fd as i32, buf.as_ptr() as *const libc::c_void, buf.len()).to_le()); + + if fd > 2 { + stream.write(&buf_ret); + } + }, + Packet::Open { name, mode, flags } => { + let buf: [u8; 4] = transmute(libc::open(name.as_ptr(), flags as i32, mode as i32).to_le()); + debug!("got {:?}", buf); + + let written = stream.write(&buf).unwrap(); + //let written = stream.write(&[0,0,0,1]).unwrap(); + + debug!("Written {}", written); + }, + Packet::Close { fd } => { + let buf: [u8; 4] = transmute(libc::close(fd as i32).to_le()); + stream.write(&buf); + }, + Packet::Read { fd, len } => { + let mut tmp: Vec = vec![0; len as usize]; + let got = libc::read(fd as i32, tmp.as_mut_ptr() as *mut libc::c_void, len as usize); + let buf: [u8; 8] = transmute(got.to_le()); + + debug!("Read size {:?}", buf); + + stream.write(&buf); + + if got > 0 { + stream.write(&tmp[..]); + } + }, + Packet::LSeek { fd, offset, whence } => { + let buf: [u8; 8] = transmute(libc::lseek(fd as i32, offset, whence as i32).to_le()); + stream.write(&buf); + } + }; + } + + state = proto::State::Id; + } + + if cur.position() == old_position { + break; + } else { + old_position = cur.position(); + } + } + } + } +} diff --git a/tools/hermit_proxy/src/error.rs b/tools/hermit_proxy/src/error.rs new file mode 100644 index 000000000..b0b118005 --- /dev/null +++ b/tools/hermit_proxy/src/error.rs @@ -0,0 +1,18 @@ +use std::result; +use nix; + +pub type Result = result::Result; + +#[derive(Debug)] +pub enum Error { + InternalError, + NotEnoughMemory, + InvalidFile, + FailedIOCTL(nix::Error), + KernelNotLoaded, + MissingFrequency, + MultiIsleFailed, + CannotCreateTmpFile(usize), + QEmu((String, String)) + +} diff --git a/tools/hermit_proxy/src/hermit.rs b/tools/hermit_proxy/src/hermit.rs new file mode 100644 index 000000000..4e7c8ec44 --- /dev/null +++ b/tools/hermit_proxy/src/hermit.rs @@ -0,0 +1,116 @@ +use std::env; +use std::fs::File; +use std::path::Path; +use std::io::{Write, Read, BufReader, BufRead}; +use inotify::INotify; +use inotify::ffi::{IN_MODIFY, IN_CREATE}; + +use hermit_env; +use dedicate::qemu::QEmu; +use dedicate::multi::Multi; +use uhyve::Uhyve; +use uhyve::vm::VirtualMachine; +use error::*; + +pub enum IsleKind { + QEMU(QEmu), + UHYVE((Uhyve, VirtualMachine)), + MULTI(Multi) +} + +impl IsleKind { + pub fn new(path: &str) -> Result { + let isle = hermit_env::isle_kind(); + + debug!("Create a new {} isle", isle); + + let isle = match isle.as_str() { + "qemu"=>IsleKind::QEMU(QEmu::new(path)?), + "uhyve" => { + let uhyve = Uhyve::new(); + let mut vm = uhyve.create_vm(0x20000000)?; + vm.load_kernel(path)?; + vm.init()?; + + IsleKind::UHYVE((uhyve, vm)) + }, + s => IsleKind::MULTI(Multi::new(s.parse::().unwrap_or(0), path)?) + }; + + Ok(isle) + } + + fn get_num(&self) -> u8 { + match *self { + IsleKind::QEMU(_) => 0, + IsleKind::UHYVE(_) => 0, + IsleKind::MULTI(ref s) => s.get_num() + } + } + + pub fn is_available(&self) -> Result { + let mut file = match *self { + IsleKind::QEMU(ref q) => File::open(q.tmp_path()), + _ => File::open(format!("/sys/hermit/isle{}/log", self.get_num())) + }; + + let mut file = file.map_err(|_| Error::InvalidFile)?; + let mut reader = BufReader::new(file); + + //let mut result = String::new(); + //file.read_to_string(&mut result).map_err(|_| Error::InvalidFile)?; + + for line in reader.lines() { + if line.unwrap().contains("TCP server is listening.") { + debug!("Found key token, continue"); + return Ok(true); + } + } + + Ok(false) + + //debug!("HERMIT - isle log contains: {}", result); + + //Ok(result == "TCP server is listening.") + } + + pub fn wait_available(&self) -> Result<()> { + debug!("HERMIT - wait to be available"); + + let mut ino = INotify::init().unwrap(); + + match *self { + IsleKind::QEMU(_) => ino.add_watch(Path::new("/tmp"), IN_MODIFY | IN_CREATE).unwrap(), + IsleKind::MULTI(_) => ino.add_watch(Path::new("/sys/hermit"), IN_MODIFY | IN_CREATE).unwrap(), + IsleKind::UHYVE(_) => return Ok(()) + }; + + loop { + let events = ino.wait_for_events().unwrap(); + + if self.is_available()? { + return Ok(()); + } + } + } + + pub fn stop(&self) -> Result<()> { + let mut cpus_file = File::create(format!("/sys/hermit/isle{}/cpus", self.get_num())) + .map_err(|_| Error::InvalidFile)?; + + cpus_file.write("-1".as_bytes()) + .map_err(|_| Error::InvalidFile); + + Ok(()) + } + + pub fn run(mut self) -> Result<()> { + match self { + IsleKind::UHYVE((_, mut vm)) => vm.run()?, + IsleKind::QEMU(qemu) => qemu.run(), + IsleKind::MULTI(multi) => multi.run() + } + + Ok(()) + } +} diff --git a/tools/hermit_proxy/src/hermit_env.rs b/tools/hermit_proxy/src/hermit_env.rs new file mode 100644 index 000000000..028ae3ce9 --- /dev/null +++ b/tools/hermit_proxy/src/hermit_env.rs @@ -0,0 +1,46 @@ +use std::env; + +pub fn isle_kind() -> String { + env::var("HERMIT_ISLE").unwrap_or("qemu".into()) +} + +pub fn qemu_binary() -> String { + env::var("HERMIT_QEMU").unwrap_or("qemu-system-x86_64".into()) +} + +pub fn num_cpus() -> String { + env::var("HERMIT_CPUS").unwrap_or("1".into()) +} + +pub fn mem_size() -> String { + env::var("HERMIT_MEM").unwrap_or("2G".into()) +} + +pub fn use_kvm() -> String { + env::var("HERMIT_KVM").unwrap_or("1".into()) +} + +pub fn monitor() -> String { + env::var("HERMIT_MONITOR").unwrap_or("0".into()) +} + +pub fn should_debug() -> String { + env::var("HERMIT_DEBUG").unwrap_or("0".into()) +} + +pub fn capture_net() -> String { + env::var("HERMIT_CAPTURE_NET").unwrap_or("0".into()) +} + +pub fn verbose() -> String { + env::var("HERMIT_VERBOSE").unwrap_or("0".into()) +} + +pub fn port() -> String { + env::var("HERMIT_PORT").unwrap_or("18766".into()) +} + +pub fn app_port() -> String { + env::var("HERMIT_APP_PORT").unwrap_or("".into()) +} + diff --git a/tools/hermit_proxy/src/main.rs b/tools/hermit_proxy/src/main.rs new file mode 100644 index 000000000..141a19488 --- /dev/null +++ b/tools/hermit_proxy/src/main.rs @@ -0,0 +1,50 @@ +#![feature(untagged_unions)] +#![allow(dead_code)] +#![allow(non_camel_case_types)] +#![allow(non_upper_case_globals)] + +#[macro_use] +extern crate log; +extern crate env_logger; + +extern crate libc; +extern crate memmap; +extern crate elf; +extern crate errno; +extern crate inotify; +extern crate byteorder; + +#[macro_use] +extern crate nix; + +mod error; +mod utils; +mod hermit; +mod uhyve; +mod dedicate; +mod hermit_env; + +use nix::sys::signal; +use std::{env, process}; + +extern fn exit(_:i32) { + panic!("Aborting .."); +} + +fn main() { + env_logger::init().unwrap(); + + let sig_action = signal::SigAction::new(signal::SigHandler::Handler(exit), signal::SaFlags::empty(), signal::SigSet::empty()); + unsafe { + signal::sigaction(signal::SIGINT, &sig_action).unwrap(); + signal::sigaction(signal::SIGTERM, &sig_action).unwrap(); + } + + if let Some(path) = env::args().skip(1).next() { + let isle = hermit::IsleKind::new(&path).unwrap(); + + isle.wait_available(); + + isle.run(); + } +} diff --git a/tools/hermit_proxy/src/uhyve/gdt.rs b/tools/hermit_proxy/src/uhyve/gdt.rs new file mode 100644 index 000000000..e8e163f9b --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/gdt.rs @@ -0,0 +1,137 @@ +//! This module wraps the structure of the GDT and helps to extract certain information about the +//! GDT. The Global Descriptor Table contains information about the memory structure used by the +//! X86 family. + +use uhyve::kvm_header::kvm_segment; + +/// Used segments in order +pub const BOOT_NULL: isize = 0; +pub const BOOT_CODE: isize = 1; +pub const BOOT_DATA: isize = 2; +pub const BOOT_MAX: usize = 3; + +/// This struct breaks the access part of a GDT entry down into functions +pub struct AccessBits { + access: u8 +} + +impl AccessBits { + pub fn present(&self) -> u8 { + (self.access & 0b10000000) >> 7 + } + + pub fn privilege(&self) -> u8 { + (self.access & 0b01100000) >> 5 + } + + pub fn s(&self) -> u8 { + (self.access & 0b00010000) >> 4 + } + + pub fn kind(&self) -> u8 { + (self.access & 0b00001111) + } + + #[inline(always)] + pub fn apply_to_kvm(&self, seg: &mut kvm_segment) { + seg.present = self.present(); + seg.dpl = self.privilege(); + seg.s = self.s(); + seg.type_ = self.kind(); + } +} + +pub struct FlagBits { + flags: u8 +} + +impl FlagBits { + pub fn granularity(&self) -> u8 { + (self.flags & 0b00001000) >> 3 + } + + pub fn size(&self) -> u8 { + (self.flags & 0b00000100) >> 2 + } + + pub fn desc_x86_64(&self) -> u8 { + (self.flags & 0b00000010) >> 1 + } + + pub fn sz_x86_64(&self) -> u8 { + (self.flags & 0b00000001) + } + + #[inline(always)] + pub fn apply_to_kvm(&self, seg: &mut kvm_segment) { + seg.g = self.granularity(); + seg.db = self.size(); + seg.l = self.desc_x86_64(); + seg.avl = self.sz_x86_64(); + } +} + +/// This struct defines the arrangment one GDT entry in memory +pub struct Entry { + pub limit_l: u16, + pub offset_l: u16, + pub offset_m: u8, + pub access: u8, + pub flags_limit_h: u8, + pub offset_h: u8 +} + +impl Entry { + pub fn new(flags: u16, offset: u32, limit: u32) -> Entry { + Entry { + limit_l: limit as u16, + offset_l: offset as u16, + offset_m: (offset >> 16) as u8, + access: flags as u8, + flags_limit_h: (limit >> 16) as u8 & 0x0F | (flags >> 8) as u8 & 0xF0, + offset_h: (offset >> 24) as u8 + } + } + + // returns the maximum addressable unit + pub fn get_limit(&self) -> u32 { + ((self.flags_limit_h & 0x0F) as u32) << 16 | (self.limit_l as u32) + } + + // returns the offset of this segment + pub fn get_offset(&self) -> u32 { + (self.offset_h as u32) << 24 | (self.offset_m as u32) << 16 | (self.offset_l as u32) + } + + // returns the access bits + pub fn get_access(&self) -> AccessBits { + AccessBits { access: self.access } + } + + // return the flags bits + pub fn get_flags(&self) -> FlagBits { + FlagBits { flags: self.flags_limit_h & 0x0F } + } + + // convert the struct to an unsigned integer + pub fn as_u64(&self) -> u64 { + (self.offset_h as u64) << 56 | + (self.flags_limit_h as u64) << 48 | + (self.access as u64) << 40 | + (self.offset_m as u64) << 32 | + (self.offset_l as u64) << 16 | + (self.limit_l as u64) << 0 + } + + #[inline(always)] + pub fn apply_to_kvm(&self, sel: isize, seg: &mut kvm_segment) { + seg.base = self.get_offset() as u64; + seg.limit = self.get_limit(); + seg.selector = sel as u16 * 8; + + self.get_access().apply_to_kvm(seg); + self.get_flags().apply_to_kvm(seg); + + } + +} diff --git a/tools/hermit_proxy/src/uhyve/kvm_header.rs b/tools/hermit_proxy/src/uhyve/kvm_header.rs new file mode 100644 index 000000000..e52e5def1 --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/kvm_header.rs @@ -0,0 +1,5767 @@ +/* automatically generated by rust-bindgen */ + +#[repr(C)] +#[derive(Default)] +pub struct __IncompleteArrayField(::std::marker::PhantomData); +impl __IncompleteArrayField { + #[inline] + pub fn new() -> Self { + __IncompleteArrayField(::std::marker::PhantomData) + } + #[inline] + pub unsafe fn as_ptr(&self) -> *const T { ::std::mem::transmute(self) } + #[inline] + pub unsafe fn as_mut_ptr(&mut self) -> *mut T { + ::std::mem::transmute(self) + } + #[inline] + pub unsafe fn as_slice(&self, len: usize) -> &[T] { + ::std::slice::from_raw_parts(self.as_ptr(), len) + } + #[inline] + pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] { + ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) + } +} +impl ::std::fmt::Debug for __IncompleteArrayField { + fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { + fmt.write_str("__IncompleteArrayField") + } +} +impl ::std::clone::Clone for __IncompleteArrayField { + #[inline] + fn clone(&self) -> Self { Self::new() } +} +impl ::std::marker::Copy for __IncompleteArrayField { } +pub const __BITS_PER_LONG: ::std::os::raw::c_uint = 64; +pub const __FD_SETSIZE: ::std::os::raw::c_uint = 1024; +pub const _IOC_NRBITS: ::std::os::raw::c_uint = 8; +pub const _IOC_TYPEBITS: ::std::os::raw::c_uint = 8; +pub const _IOC_SIZEBITS: ::std::os::raw::c_uint = 14; +pub const _IOC_DIRBITS: ::std::os::raw::c_uint = 2; +pub const _IOC_NRMASK: ::std::os::raw::c_uint = 255; +pub const _IOC_TYPEMASK: ::std::os::raw::c_uint = 255; +pub const _IOC_SIZEMASK: ::std::os::raw::c_uint = 16383; +pub const _IOC_DIRMASK: ::std::os::raw::c_uint = 3; +pub const _IOC_NRSHIFT: ::std::os::raw::c_uint = 0; +pub const _IOC_TYPESHIFT: ::std::os::raw::c_uint = 8; +pub const _IOC_SIZESHIFT: ::std::os::raw::c_uint = 16; +pub const _IOC_DIRSHIFT: ::std::os::raw::c_uint = 30; +pub const _IOC_NONE: ::std::os::raw::c_uint = 0; +pub const _IOC_WRITE: ::std::os::raw::c_uint = 1; +pub const _IOC_READ: ::std::os::raw::c_uint = 2; +pub const IOC_IN: ::std::os::raw::c_uint = 1073741824; +pub const IOC_OUT: ::std::os::raw::c_uint = 2147483648; +pub const IOC_INOUT: ::std::os::raw::c_uint = 3221225472; +pub const IOCSIZE_MASK: ::std::os::raw::c_uint = 1073676288; +pub const IOCSIZE_SHIFT: ::std::os::raw::c_uint = 16; +pub const DE_VECTOR: ::std::os::raw::c_uint = 0; +pub const DB_VECTOR: ::std::os::raw::c_uint = 1; +pub const BP_VECTOR: ::std::os::raw::c_uint = 3; +pub const OF_VECTOR: ::std::os::raw::c_uint = 4; +pub const BR_VECTOR: ::std::os::raw::c_uint = 5; +pub const UD_VECTOR: ::std::os::raw::c_uint = 6; +pub const NM_VECTOR: ::std::os::raw::c_uint = 7; +pub const DF_VECTOR: ::std::os::raw::c_uint = 8; +pub const TS_VECTOR: ::std::os::raw::c_uint = 10; +pub const NP_VECTOR: ::std::os::raw::c_uint = 11; +pub const SS_VECTOR: ::std::os::raw::c_uint = 12; +pub const GP_VECTOR: ::std::os::raw::c_uint = 13; +pub const PF_VECTOR: ::std::os::raw::c_uint = 14; +pub const MF_VECTOR: ::std::os::raw::c_uint = 16; +pub const AC_VECTOR: ::std::os::raw::c_uint = 17; +pub const MC_VECTOR: ::std::os::raw::c_uint = 18; +pub const XM_VECTOR: ::std::os::raw::c_uint = 19; +pub const VE_VECTOR: ::std::os::raw::c_uint = 20; +pub const KVM_NR_INTERRUPTS: ::std::os::raw::c_uint = 256; +pub const KVM_IOAPIC_NUM_PINS: ::std::os::raw::c_uint = 24; +pub const KVM_IRQCHIP_PIC_MASTER: ::std::os::raw::c_uint = 0; +pub const KVM_IRQCHIP_PIC_SLAVE: ::std::os::raw::c_uint = 1; +pub const KVM_IRQCHIP_IOAPIC: ::std::os::raw::c_uint = 2; +pub const KVM_NR_IRQCHIPS: ::std::os::raw::c_uint = 3; +pub const KVM_RUN_X86_SMM: ::std::os::raw::c_uint = 1; +pub const KVM_APIC_REG_SIZE: ::std::os::raw::c_uint = 1024; +pub const KVM_CPUID_FLAG_SIGNIFCANT_INDEX: ::std::os::raw::c_uint = 1; +pub const KVM_CPUID_FLAG_STATEFUL_FUNC: ::std::os::raw::c_uint = 2; +pub const KVM_CPUID_FLAG_STATE_READ_NEXT: ::std::os::raw::c_uint = 4; +pub const KVM_GUESTDBG_USE_SW_BP: ::std::os::raw::c_uint = 65536; +pub const KVM_GUESTDBG_USE_HW_BP: ::std::os::raw::c_uint = 131072; +pub const KVM_GUESTDBG_INJECT_DB: ::std::os::raw::c_uint = 262144; +pub const KVM_GUESTDBG_INJECT_BP: ::std::os::raw::c_uint = 524288; +pub const KVM_PIT_FLAGS_HPET_LEGACY: ::std::os::raw::c_uint = 1; +pub const KVM_VCPUEVENT_VALID_NMI_PENDING: ::std::os::raw::c_uint = 1; +pub const KVM_VCPUEVENT_VALID_SIPI_VECTOR: ::std::os::raw::c_uint = 2; +pub const KVM_VCPUEVENT_VALID_SHADOW: ::std::os::raw::c_uint = 4; +pub const KVM_VCPUEVENT_VALID_SMM: ::std::os::raw::c_uint = 8; +pub const KVM_X86_SHADOW_INT_MOV_SS: ::std::os::raw::c_uint = 1; +pub const KVM_X86_SHADOW_INT_STI: ::std::os::raw::c_uint = 2; +pub const KVM_MAX_XCRS: ::std::os::raw::c_uint = 16; +pub const KVM_X86_QUIRK_LINT0_REENABLED: ::std::os::raw::c_uint = 1; +pub const KVM_X86_QUIRK_CD_NW_CLEARED: ::std::os::raw::c_uint = 2; +pub const KVM_API_VERSION: ::std::os::raw::c_uint = 12; +pub const KVM_TRC_SHIFT: ::std::os::raw::c_uint = 16; +pub const KVM_TRC_ENTRYEXIT: ::std::os::raw::c_uint = 65536; +pub const KVM_TRC_HANDLER: ::std::os::raw::c_uint = 131072; +pub const KVM_TRC_VMENTRY: ::std::os::raw::c_uint = 65537; +pub const KVM_TRC_VMEXIT: ::std::os::raw::c_uint = 65538; +pub const KVM_TRC_PAGE_FAULT: ::std::os::raw::c_uint = 131073; +pub const KVM_TRC_HEAD_SIZE: ::std::os::raw::c_uint = 12; +pub const KVM_TRC_CYCLE_SIZE: ::std::os::raw::c_uint = 8; +pub const KVM_TRC_EXTRA_MAX: ::std::os::raw::c_uint = 7; +pub const KVM_TRC_INJ_VIRQ: ::std::os::raw::c_uint = 131074; +pub const KVM_TRC_REDELIVER_EVT: ::std::os::raw::c_uint = 131075; +pub const KVM_TRC_PEND_INTR: ::std::os::raw::c_uint = 131076; +pub const KVM_TRC_IO_READ: ::std::os::raw::c_uint = 131077; +pub const KVM_TRC_IO_WRITE: ::std::os::raw::c_uint = 131078; +pub const KVM_TRC_CR_READ: ::std::os::raw::c_uint = 131079; +pub const KVM_TRC_CR_WRITE: ::std::os::raw::c_uint = 131080; +pub const KVM_TRC_DR_READ: ::std::os::raw::c_uint = 131081; +pub const KVM_TRC_DR_WRITE: ::std::os::raw::c_uint = 131082; +pub const KVM_TRC_MSR_READ: ::std::os::raw::c_uint = 131083; +pub const KVM_TRC_MSR_WRITE: ::std::os::raw::c_uint = 131084; +pub const KVM_TRC_CPUID: ::std::os::raw::c_uint = 131085; +pub const KVM_TRC_INTR: ::std::os::raw::c_uint = 131086; +pub const KVM_TRC_NMI: ::std::os::raw::c_uint = 131087; +pub const KVM_TRC_VMMCALL: ::std::os::raw::c_uint = 131088; +pub const KVM_TRC_HLT: ::std::os::raw::c_uint = 131089; +pub const KVM_TRC_CLTS: ::std::os::raw::c_uint = 131090; +pub const KVM_TRC_LMSW: ::std::os::raw::c_uint = 131091; +pub const KVM_TRC_APIC_ACCESS: ::std::os::raw::c_uint = 131092; +pub const KVM_TRC_TDP_FAULT: ::std::os::raw::c_uint = 131093; +pub const KVM_TRC_GTLB_WRITE: ::std::os::raw::c_uint = 131094; +pub const KVM_TRC_STLB_WRITE: ::std::os::raw::c_uint = 131095; +pub const KVM_TRC_STLB_INVAL: ::std::os::raw::c_uint = 131096; +pub const KVM_TRC_PPC_INSTR: ::std::os::raw::c_uint = 131097; +pub const KVM_MEM_LOG_DIRTY_PAGES: ::std::os::raw::c_uint = 1; +pub const KVM_MEM_READONLY: ::std::os::raw::c_uint = 2; +pub const KVM_PIT_SPEAKER_DUMMY: ::std::os::raw::c_uint = 1; +pub const KVM_EXIT_HYPERV_SYNIC: ::std::os::raw::c_uint = 1; +pub const KVM_S390_GET_SKEYS_NONE: ::std::os::raw::c_uint = 1; +pub const KVM_S390_SKEYS_MAX: ::std::os::raw::c_uint = 1048576; +pub const KVM_EXIT_UNKNOWN: ::std::os::raw::c_uint = 0; +pub const KVM_EXIT_EXCEPTION: ::std::os::raw::c_uint = 1; +pub const KVM_EXIT_IO: ::std::os::raw::c_uint = 2; +pub const KVM_EXIT_HYPERCALL: ::std::os::raw::c_uint = 3; +pub const KVM_EXIT_DEBUG: ::std::os::raw::c_uint = 4; +pub const KVM_EXIT_HLT: ::std::os::raw::c_uint = 5; +pub const KVM_EXIT_MMIO: ::std::os::raw::c_uint = 6; +pub const KVM_EXIT_IRQ_WINDOW_OPEN: ::std::os::raw::c_uint = 7; +pub const KVM_EXIT_SHUTDOWN: ::std::os::raw::c_uint = 8; +pub const KVM_EXIT_FAIL_ENTRY: ::std::os::raw::c_uint = 9; +pub const KVM_EXIT_INTR: ::std::os::raw::c_uint = 10; +pub const KVM_EXIT_SET_TPR: ::std::os::raw::c_uint = 11; +pub const KVM_EXIT_TPR_ACCESS: ::std::os::raw::c_uint = 12; +pub const KVM_EXIT_S390_SIEIC: ::std::os::raw::c_uint = 13; +pub const KVM_EXIT_S390_RESET: ::std::os::raw::c_uint = 14; +pub const KVM_EXIT_DCR: ::std::os::raw::c_uint = 15; +pub const KVM_EXIT_NMI: ::std::os::raw::c_uint = 16; +pub const KVM_EXIT_INTERNAL_ERROR: ::std::os::raw::c_uint = 17; +pub const KVM_EXIT_OSI: ::std::os::raw::c_uint = 18; +pub const KVM_EXIT_PAPR_HCALL: ::std::os::raw::c_uint = 19; +pub const KVM_EXIT_S390_UCONTROL: ::std::os::raw::c_uint = 20; +pub const KVM_EXIT_WATCHDOG: ::std::os::raw::c_uint = 21; +pub const KVM_EXIT_S390_TSCH: ::std::os::raw::c_uint = 22; +pub const KVM_EXIT_EPR: ::std::os::raw::c_uint = 23; +pub const KVM_EXIT_SYSTEM_EVENT: ::std::os::raw::c_uint = 24; +pub const KVM_EXIT_S390_STSI: ::std::os::raw::c_uint = 25; +pub const KVM_EXIT_IOAPIC_EOI: ::std::os::raw::c_uint = 26; +pub const KVM_EXIT_HYPERV: ::std::os::raw::c_uint = 27; +pub const KVM_INTERNAL_ERROR_EMULATION: ::std::os::raw::c_uint = 1; +pub const KVM_INTERNAL_ERROR_SIMUL_EX: ::std::os::raw::c_uint = 2; +pub const KVM_INTERNAL_ERROR_DELIVERY_EV: ::std::os::raw::c_uint = 3; +pub const KVM_EXIT_IO_IN: ::std::os::raw::c_uint = 0; +pub const KVM_S390_RESET_POR: ::std::os::raw::c_uint = 1; +pub const KVM_S390_RESET_CLEAR: ::std::os::raw::c_uint = 2; +pub const KVM_S390_RESET_SUBSYSTEM: ::std::os::raw::c_uint = 4; +pub const KVM_S390_RESET_CPU_INIT: ::std::os::raw::c_uint = 8; +pub const KVM_SYSTEM_EVENT_SHUTDOWN: ::std::os::raw::c_uint = 1; +pub const KVM_SYSTEM_EVENT_RESET: ::std::os::raw::c_uint = 2; +pub const KVM_S390_MEMOP_LOGICAL_READ: ::std::os::raw::c_uint = 0; +pub const KVM_S390_MEMOP_LOGICAL_WRITE: ::std::os::raw::c_uint = 1; +pub const KVM_S390_MEMOP_F_CHECK_ONLY: ::std::os::raw::c_uint = 1; +pub const KVM_S390_MEMOP_F_INJECT_EXCEPTION: ::std::os::raw::c_uint = 2; +pub const KVM_MP_STATE_RUNNABLE: ::std::os::raw::c_uint = 0; +pub const KVM_MP_STATE_UNINITIALIZED: ::std::os::raw::c_uint = 1; +pub const KVM_MP_STATE_INIT_RECEIVED: ::std::os::raw::c_uint = 2; +pub const KVM_MP_STATE_HALTED: ::std::os::raw::c_uint = 3; +pub const KVM_MP_STATE_SIPI_RECEIVED: ::std::os::raw::c_uint = 4; +pub const KVM_MP_STATE_STOPPED: ::std::os::raw::c_uint = 5; +pub const KVM_MP_STATE_CHECK_STOP: ::std::os::raw::c_uint = 6; +pub const KVM_MP_STATE_OPERATING: ::std::os::raw::c_uint = 7; +pub const KVM_MP_STATE_LOAD: ::std::os::raw::c_uint = 8; +pub const KVM_S390_SIGP_STOP: ::std::os::raw::c_uint = 4294836224; +pub const KVM_S390_PROGRAM_INT: ::std::os::raw::c_uint = 4294836225; +pub const KVM_S390_SIGP_SET_PREFIX: ::std::os::raw::c_uint = 4294836226; +pub const KVM_S390_RESTART: ::std::os::raw::c_uint = 4294836227; +pub const KVM_S390_INT_PFAULT_INIT: ::std::os::raw::c_uint = 4294836228; +pub const KVM_S390_INT_PFAULT_DONE: ::std::os::raw::c_uint = 4294836229; +pub const KVM_S390_MCHK: ::std::os::raw::c_uint = 4294840320; +pub const KVM_S390_INT_CLOCK_COMP: ::std::os::raw::c_uint = 4294905860; +pub const KVM_S390_INT_CPU_TIMER: ::std::os::raw::c_uint = 4294905861; +pub const KVM_S390_INT_VIRTIO: ::std::os::raw::c_uint = 4294911491; +pub const KVM_S390_INT_SERVICE: ::std::os::raw::c_uint = 4294910977; +pub const KVM_S390_INT_EMERGENCY: ::std::os::raw::c_uint = 4294906369; +pub const KVM_S390_INT_EXTERNAL_CALL: ::std::os::raw::c_uint = 4294906370; +pub const KVM_S390_INT_IO_MIN: ::std::os::raw::c_uint = 0; +pub const KVM_S390_INT_IO_MAX: ::std::os::raw::c_uint = 4294836223; +pub const KVM_S390_INT_IO_AI_MASK: ::std::os::raw::c_uint = 67108864; +pub const KVM_S390_PGM_FLAGS_ILC_VALID: ::std::os::raw::c_uint = 1; +pub const KVM_S390_PGM_FLAGS_ILC_0: ::std::os::raw::c_uint = 2; +pub const KVM_S390_PGM_FLAGS_ILC_1: ::std::os::raw::c_uint = 4; +pub const KVM_S390_PGM_FLAGS_ILC_MASK: ::std::os::raw::c_uint = 6; +pub const KVM_S390_STOP_FLAG_STORE_STATUS: ::std::os::raw::c_uint = 1; +pub const KVM_GUESTDBG_ENABLE: ::std::os::raw::c_uint = 1; +pub const KVM_GUESTDBG_SINGLESTEP: ::std::os::raw::c_uint = 2; +pub const KVM_PPC_PAGE_SIZES_MAX_SZ: ::std::os::raw::c_uint = 8; +pub const KVM_PPC_PAGE_SIZES_REAL: ::std::os::raw::c_uint = 1; +pub const KVM_PPC_1T_SEGMENTS: ::std::os::raw::c_uint = 2; +pub const KVM_PPC_PVINFO_FLAGS_EV_IDLE: ::std::os::raw::c_uint = 1; +pub const KVMIO: ::std::os::raw::c_uint = 174; +pub const KVM_VM_S390_UCONTROL: ::std::os::raw::c_uint = 1; +pub const KVM_VM_PPC_HV: ::std::os::raw::c_uint = 1; +pub const KVM_VM_PPC_PR: ::std::os::raw::c_uint = 2; +pub const KVM_S390_SIE_PAGE_OFFSET: ::std::os::raw::c_uint = 1; +pub const KVM_CAP_IRQCHIP: ::std::os::raw::c_uint = 0; +pub const KVM_CAP_HLT: ::std::os::raw::c_uint = 1; +pub const KVM_CAP_MMU_SHADOW_CACHE_CONTROL: ::std::os::raw::c_uint = 2; +pub const KVM_CAP_USER_MEMORY: ::std::os::raw::c_uint = 3; +pub const KVM_CAP_SET_TSS_ADDR: ::std::os::raw::c_uint = 4; +pub const KVM_CAP_VAPIC: ::std::os::raw::c_uint = 6; +pub const KVM_CAP_EXT_CPUID: ::std::os::raw::c_uint = 7; +pub const KVM_CAP_CLOCKSOURCE: ::std::os::raw::c_uint = 8; +pub const KVM_CAP_NR_VCPUS: ::std::os::raw::c_uint = 9; +pub const KVM_CAP_NR_MEMSLOTS: ::std::os::raw::c_uint = 10; +pub const KVM_CAP_PIT: ::std::os::raw::c_uint = 11; +pub const KVM_CAP_NOP_IO_DELAY: ::std::os::raw::c_uint = 12; +pub const KVM_CAP_PV_MMU: ::std::os::raw::c_uint = 13; +pub const KVM_CAP_MP_STATE: ::std::os::raw::c_uint = 14; +pub const KVM_CAP_COALESCED_MMIO: ::std::os::raw::c_uint = 15; +pub const KVM_CAP_SYNC_MMU: ::std::os::raw::c_uint = 16; +pub const KVM_CAP_IOMMU: ::std::os::raw::c_uint = 18; +pub const KVM_CAP_DESTROY_MEMORY_REGION_WORKS: ::std::os::raw::c_uint = 21; +pub const KVM_CAP_USER_NMI: ::std::os::raw::c_uint = 22; +pub const KVM_CAP_SET_GUEST_DEBUG: ::std::os::raw::c_uint = 23; +pub const KVM_CAP_REINJECT_CONTROL: ::std::os::raw::c_uint = 24; +pub const KVM_CAP_IRQ_ROUTING: ::std::os::raw::c_uint = 25; +pub const KVM_CAP_IRQ_INJECT_STATUS: ::std::os::raw::c_uint = 26; +pub const KVM_CAP_ASSIGN_DEV_IRQ: ::std::os::raw::c_uint = 29; +pub const KVM_CAP_JOIN_MEMORY_REGIONS_WORKS: ::std::os::raw::c_uint = 30; +pub const KVM_CAP_MCE: ::std::os::raw::c_uint = 31; +pub const KVM_CAP_IRQFD: ::std::os::raw::c_uint = 32; +pub const KVM_CAP_PIT2: ::std::os::raw::c_uint = 33; +pub const KVM_CAP_SET_BOOT_CPU_ID: ::std::os::raw::c_uint = 34; +pub const KVM_CAP_PIT_STATE2: ::std::os::raw::c_uint = 35; +pub const KVM_CAP_IOEVENTFD: ::std::os::raw::c_uint = 36; +pub const KVM_CAP_SET_IDENTITY_MAP_ADDR: ::std::os::raw::c_uint = 37; +pub const KVM_CAP_XEN_HVM: ::std::os::raw::c_uint = 38; +pub const KVM_CAP_ADJUST_CLOCK: ::std::os::raw::c_uint = 39; +pub const KVM_CAP_INTERNAL_ERROR_DATA: ::std::os::raw::c_uint = 40; +pub const KVM_CAP_VCPU_EVENTS: ::std::os::raw::c_uint = 41; +pub const KVM_CAP_S390_PSW: ::std::os::raw::c_uint = 42; +pub const KVM_CAP_PPC_SEGSTATE: ::std::os::raw::c_uint = 43; +pub const KVM_CAP_HYPERV: ::std::os::raw::c_uint = 44; +pub const KVM_CAP_HYPERV_VAPIC: ::std::os::raw::c_uint = 45; +pub const KVM_CAP_HYPERV_SPIN: ::std::os::raw::c_uint = 46; +pub const KVM_CAP_PCI_SEGMENT: ::std::os::raw::c_uint = 47; +pub const KVM_CAP_PPC_PAIRED_SINGLES: ::std::os::raw::c_uint = 48; +pub const KVM_CAP_INTR_SHADOW: ::std::os::raw::c_uint = 49; +pub const KVM_CAP_DEBUGREGS: ::std::os::raw::c_uint = 50; +pub const KVM_CAP_X86_ROBUST_SINGLESTEP: ::std::os::raw::c_uint = 51; +pub const KVM_CAP_PPC_OSI: ::std::os::raw::c_uint = 52; +pub const KVM_CAP_PPC_UNSET_IRQ: ::std::os::raw::c_uint = 53; +pub const KVM_CAP_ENABLE_CAP: ::std::os::raw::c_uint = 54; +pub const KVM_CAP_XSAVE: ::std::os::raw::c_uint = 55; +pub const KVM_CAP_XCRS: ::std::os::raw::c_uint = 56; +pub const KVM_CAP_PPC_GET_PVINFO: ::std::os::raw::c_uint = 57; +pub const KVM_CAP_PPC_IRQ_LEVEL: ::std::os::raw::c_uint = 58; +pub const KVM_CAP_ASYNC_PF: ::std::os::raw::c_uint = 59; +pub const KVM_CAP_TSC_CONTROL: ::std::os::raw::c_uint = 60; +pub const KVM_CAP_GET_TSC_KHZ: ::std::os::raw::c_uint = 61; +pub const KVM_CAP_PPC_BOOKE_SREGS: ::std::os::raw::c_uint = 62; +pub const KVM_CAP_SPAPR_TCE: ::std::os::raw::c_uint = 63; +pub const KVM_CAP_PPC_SMT: ::std::os::raw::c_uint = 64; +pub const KVM_CAP_PPC_RMA: ::std::os::raw::c_uint = 65; +pub const KVM_CAP_MAX_VCPUS: ::std::os::raw::c_uint = 66; +pub const KVM_CAP_PPC_HIOR: ::std::os::raw::c_uint = 67; +pub const KVM_CAP_PPC_PAPR: ::std::os::raw::c_uint = 68; +pub const KVM_CAP_SW_TLB: ::std::os::raw::c_uint = 69; +pub const KVM_CAP_ONE_REG: ::std::os::raw::c_uint = 70; +pub const KVM_CAP_S390_GMAP: ::std::os::raw::c_uint = 71; +pub const KVM_CAP_TSC_DEADLINE_TIMER: ::std::os::raw::c_uint = 72; +pub const KVM_CAP_S390_UCONTROL: ::std::os::raw::c_uint = 73; +pub const KVM_CAP_SYNC_REGS: ::std::os::raw::c_uint = 74; +pub const KVM_CAP_PCI_2_3: ::std::os::raw::c_uint = 75; +pub const KVM_CAP_KVMCLOCK_CTRL: ::std::os::raw::c_uint = 76; +pub const KVM_CAP_SIGNAL_MSI: ::std::os::raw::c_uint = 77; +pub const KVM_CAP_PPC_GET_SMMU_INFO: ::std::os::raw::c_uint = 78; +pub const KVM_CAP_S390_COW: ::std::os::raw::c_uint = 79; +pub const KVM_CAP_PPC_ALLOC_HTAB: ::std::os::raw::c_uint = 80; +pub const KVM_CAP_READONLY_MEM: ::std::os::raw::c_uint = 81; +pub const KVM_CAP_IRQFD_RESAMPLE: ::std::os::raw::c_uint = 82; +pub const KVM_CAP_PPC_BOOKE_WATCHDOG: ::std::os::raw::c_uint = 83; +pub const KVM_CAP_PPC_HTAB_FD: ::std::os::raw::c_uint = 84; +pub const KVM_CAP_S390_CSS_SUPPORT: ::std::os::raw::c_uint = 85; +pub const KVM_CAP_PPC_EPR: ::std::os::raw::c_uint = 86; +pub const KVM_CAP_ARM_PSCI: ::std::os::raw::c_uint = 87; +pub const KVM_CAP_ARM_SET_DEVICE_ADDR: ::std::os::raw::c_uint = 88; +pub const KVM_CAP_DEVICE_CTRL: ::std::os::raw::c_uint = 89; +pub const KVM_CAP_IRQ_MPIC: ::std::os::raw::c_uint = 90; +pub const KVM_CAP_PPC_RTAS: ::std::os::raw::c_uint = 91; +pub const KVM_CAP_IRQ_XICS: ::std::os::raw::c_uint = 92; +pub const KVM_CAP_ARM_EL1_32BIT: ::std::os::raw::c_uint = 93; +pub const KVM_CAP_SPAPR_MULTITCE: ::std::os::raw::c_uint = 94; +pub const KVM_CAP_EXT_EMUL_CPUID: ::std::os::raw::c_uint = 95; +pub const KVM_CAP_HYPERV_TIME: ::std::os::raw::c_uint = 96; +pub const KVM_CAP_IOAPIC_POLARITY_IGNORED: ::std::os::raw::c_uint = 97; +pub const KVM_CAP_ENABLE_CAP_VM: ::std::os::raw::c_uint = 98; +pub const KVM_CAP_S390_IRQCHIP: ::std::os::raw::c_uint = 99; +pub const KVM_CAP_IOEVENTFD_NO_LENGTH: ::std::os::raw::c_uint = 100; +pub const KVM_CAP_VM_ATTRIBUTES: ::std::os::raw::c_uint = 101; +pub const KVM_CAP_ARM_PSCI_0_2: ::std::os::raw::c_uint = 102; +pub const KVM_CAP_PPC_FIXUP_HCALL: ::std::os::raw::c_uint = 103; +pub const KVM_CAP_PPC_ENABLE_HCALL: ::std::os::raw::c_uint = 104; +pub const KVM_CAP_CHECK_EXTENSION_VM: ::std::os::raw::c_uint = 105; +pub const KVM_CAP_S390_USER_SIGP: ::std::os::raw::c_uint = 106; +pub const KVM_CAP_S390_VECTOR_REGISTERS: ::std::os::raw::c_uint = 107; +pub const KVM_CAP_S390_MEM_OP: ::std::os::raw::c_uint = 108; +pub const KVM_CAP_S390_USER_STSI: ::std::os::raw::c_uint = 109; +pub const KVM_CAP_S390_SKEYS: ::std::os::raw::c_uint = 110; +pub const KVM_CAP_MIPS_FPU: ::std::os::raw::c_uint = 111; +pub const KVM_CAP_MIPS_MSA: ::std::os::raw::c_uint = 112; +pub const KVM_CAP_S390_INJECT_IRQ: ::std::os::raw::c_uint = 113; +pub const KVM_CAP_S390_IRQ_STATE: ::std::os::raw::c_uint = 114; +pub const KVM_CAP_PPC_HWRNG: ::std::os::raw::c_uint = 115; +pub const KVM_CAP_DISABLE_QUIRKS: ::std::os::raw::c_uint = 116; +pub const KVM_CAP_X86_SMM: ::std::os::raw::c_uint = 117; +pub const KVM_CAP_MULTI_ADDRESS_SPACE: ::std::os::raw::c_uint = 118; +pub const KVM_CAP_GUEST_DEBUG_HW_BPS: ::std::os::raw::c_uint = 119; +pub const KVM_CAP_GUEST_DEBUG_HW_WPS: ::std::os::raw::c_uint = 120; +pub const KVM_CAP_SPLIT_IRQCHIP: ::std::os::raw::c_uint = 121; +pub const KVM_CAP_IOEVENTFD_ANY_LENGTH: ::std::os::raw::c_uint = 122; +pub const KVM_CAP_HYPERV_SYNIC: ::std::os::raw::c_uint = 123; +pub const KVM_CAP_S390_RI: ::std::os::raw::c_uint = 124; +pub const KVM_CAP_SPAPR_TCE_64: ::std::os::raw::c_uint = 125; +pub const KVM_CAP_ARM_PMU_V3: ::std::os::raw::c_uint = 126; +pub const KVM_CAP_VCPU_ATTRIBUTES: ::std::os::raw::c_uint = 127; +pub const KVM_CAP_MAX_VCPU_ID: ::std::os::raw::c_uint = 128; +pub const KVM_IRQ_ROUTING_IRQCHIP: ::std::os::raw::c_uint = 1; +pub const KVM_IRQ_ROUTING_MSI: ::std::os::raw::c_uint = 2; +pub const KVM_IRQ_ROUTING_S390_ADAPTER: ::std::os::raw::c_uint = 3; +pub const KVM_IRQ_ROUTING_HV_SINT: ::std::os::raw::c_uint = 4; +pub const KVM_IRQFD_FLAG_DEASSIGN: ::std::os::raw::c_uint = 1; +pub const KVM_IRQFD_FLAG_RESAMPLE: ::std::os::raw::c_uint = 2; +pub const KVM_MMU_FSL_BOOKE_NOHV: ::std::os::raw::c_uint = 0; +pub const KVM_MMU_FSL_BOOKE_HV: ::std::os::raw::c_uint = 1; +pub const KVM_REG_ARCH_MASK: ::std::os::raw::c_longlong = -72057594037927936; +pub const KVM_REG_GENERIC: ::std::os::raw::c_uint = 0; +pub const KVM_REG_PPC: ::std::os::raw::c_ulonglong = 1152921504606846976; +pub const KVM_REG_X86: ::std::os::raw::c_ulonglong = 2305843009213693952; +pub const KVM_REG_IA64: ::std::os::raw::c_ulonglong = 3458764513820540928; +pub const KVM_REG_ARM: ::std::os::raw::c_ulonglong = 4611686018427387904; +pub const KVM_REG_S390: ::std::os::raw::c_ulonglong = 5764607523034234880; +pub const KVM_REG_ARM64: ::std::os::raw::c_ulonglong = 6917529027641081856; +pub const KVM_REG_MIPS: ::std::os::raw::c_ulonglong = 8070450532247928832; +pub const KVM_REG_SIZE_SHIFT: ::std::os::raw::c_uint = 52; +pub const KVM_REG_SIZE_MASK: ::std::os::raw::c_ulonglong = 67553994410557440; +pub const KVM_REG_SIZE_U8: ::std::os::raw::c_uint = 0; +pub const KVM_REG_SIZE_U16: ::std::os::raw::c_ulonglong = 4503599627370496; +pub const KVM_REG_SIZE_U32: ::std::os::raw::c_ulonglong = 9007199254740992; +pub const KVM_REG_SIZE_U64: ::std::os::raw::c_ulonglong = 13510798882111488; +pub const KVM_REG_SIZE_U128: ::std::os::raw::c_ulonglong = 18014398509481984; +pub const KVM_REG_SIZE_U256: ::std::os::raw::c_ulonglong = 22517998136852480; +pub const KVM_REG_SIZE_U512: ::std::os::raw::c_ulonglong = 27021597764222976; +pub const KVM_REG_SIZE_U1024: ::std::os::raw::c_ulonglong = 31525197391593472; +pub const KVM_CREATE_DEVICE_TEST: ::std::os::raw::c_uint = 1; +pub const KVM_DEV_VFIO_GROUP: ::std::os::raw::c_uint = 1; +pub const KVM_DEV_VFIO_GROUP_ADD: ::std::os::raw::c_uint = 1; +pub const KVM_DEV_VFIO_GROUP_DEL: ::std::os::raw::c_uint = 2; +pub const KVM_S390_STORE_STATUS_NOADDR: ::std::os::raw::c_int = -1; +pub const KVM_S390_STORE_STATUS_PREFIXED: ::std::os::raw::c_int = -2; +pub const KVM_DEV_ASSIGN_ENABLE_IOMMU: ::std::os::raw::c_uint = 1; +pub const KVM_DEV_ASSIGN_PCI_2_3: ::std::os::raw::c_uint = 2; +pub const KVM_DEV_ASSIGN_MASK_INTX: ::std::os::raw::c_uint = 4; +pub const KVM_DEV_IRQ_HOST_INTX: ::std::os::raw::c_uint = 1; +pub const KVM_DEV_IRQ_HOST_MSI: ::std::os::raw::c_uint = 2; +pub const KVM_DEV_IRQ_HOST_MSIX: ::std::os::raw::c_uint = 4; +pub const KVM_DEV_IRQ_GUEST_INTX: ::std::os::raw::c_uint = 256; +pub const KVM_DEV_IRQ_GUEST_MSI: ::std::os::raw::c_uint = 512; +pub const KVM_DEV_IRQ_GUEST_MSIX: ::std::os::raw::c_uint = 1024; +pub const KVM_DEV_IRQ_HOST_MASK: ::std::os::raw::c_uint = 255; +pub const KVM_DEV_IRQ_GUEST_MASK: ::std::os::raw::c_uint = 65280; +pub const KVM_MAX_MSIX_PER_DEV: ::std::os::raw::c_uint = 256; +pub type __s8 = ::std::os::raw::c_char; +pub type __u8 = ::std::os::raw::c_uchar; +pub type __s16 = ::std::os::raw::c_short; +pub type __u16 = ::std::os::raw::c_ushort; +pub type __s32 = ::std::os::raw::c_int; +pub type __u32 = ::std::os::raw::c_uint; +pub type __s64 = ::std::os::raw::c_longlong; +pub type __u64 = ::std::os::raw::c_ulonglong; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct __kernel_fd_set { + pub fds_bits: [::std::os::raw::c_ulong; 16usize], +} +#[test] +fn bindgen_test_layout___kernel_fd_set() { + assert_eq!(::std::mem::size_of::<__kernel_fd_set>() , 128usize , concat ! + ( "Size of: " , stringify ! ( __kernel_fd_set ) )); + assert_eq! (::std::mem::align_of::<__kernel_fd_set>() , 8usize , concat ! + ( "Alignment of " , stringify ! ( __kernel_fd_set ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __kernel_fd_set ) ) . fds_bits as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( __kernel_fd_set ) , + "::" , stringify ! ( fds_bits ) )); +} +impl Clone for __kernel_fd_set { + fn clone(&self) -> Self { *self } +} +pub type __kernel_sighandler_t = + ::std::option::Option; +pub type __kernel_key_t = ::std::os::raw::c_int; +pub type __kernel_mqd_t = ::std::os::raw::c_int; +pub type __kernel_old_uid_t = ::std::os::raw::c_ushort; +pub type __kernel_old_gid_t = ::std::os::raw::c_ushort; +pub type __kernel_old_dev_t = ::std::os::raw::c_ulong; +pub type __kernel_long_t = ::std::os::raw::c_long; +pub type __kernel_ulong_t = ::std::os::raw::c_ulong; +pub type __kernel_ino_t = __kernel_ulong_t; +pub type __kernel_mode_t = ::std::os::raw::c_uint; +pub type __kernel_pid_t = ::std::os::raw::c_int; +pub type __kernel_ipc_pid_t = ::std::os::raw::c_int; +pub type __kernel_uid_t = ::std::os::raw::c_uint; +pub type __kernel_gid_t = ::std::os::raw::c_uint; +pub type __kernel_suseconds_t = __kernel_long_t; +pub type __kernel_daddr_t = ::std::os::raw::c_int; +pub type __kernel_uid32_t = ::std::os::raw::c_uint; +pub type __kernel_gid32_t = ::std::os::raw::c_uint; +pub type __kernel_size_t = __kernel_ulong_t; +pub type __kernel_ssize_t = __kernel_long_t; +pub type __kernel_ptrdiff_t = __kernel_long_t; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct __kernel_fsid_t { + pub val: [::std::os::raw::c_int; 2usize], +} +#[test] +fn bindgen_test_layout___kernel_fsid_t() { + assert_eq!(::std::mem::size_of::<__kernel_fsid_t>() , 8usize , concat ! ( + "Size of: " , stringify ! ( __kernel_fsid_t ) )); + assert_eq! (::std::mem::align_of::<__kernel_fsid_t>() , 4usize , concat ! + ( "Alignment of " , stringify ! ( __kernel_fsid_t ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const __kernel_fsid_t ) ) . val as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( __kernel_fsid_t ) , + "::" , stringify ! ( val ) )); +} +impl Clone for __kernel_fsid_t { + fn clone(&self) -> Self { *self } +} +pub type __kernel_off_t = __kernel_long_t; +pub type __kernel_loff_t = ::std::os::raw::c_longlong; +pub type __kernel_time_t = __kernel_long_t; +pub type __kernel_clock_t = __kernel_long_t; +pub type __kernel_timer_t = ::std::os::raw::c_int; +pub type __kernel_clockid_t = ::std::os::raw::c_int; +pub type __kernel_caddr_t = *mut ::std::os::raw::c_char; +pub type __kernel_uid16_t = ::std::os::raw::c_ushort; +pub type __kernel_gid16_t = ::std::os::raw::c_ushort; +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 __sum16 = __u16; +pub type __wsum = __u32; +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_memory_alias { + pub slot: __u32, + pub flags: __u32, + pub guest_phys_addr: __u64, + pub memory_size: __u64, + pub target_phys_addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_memory_alias() { + assert_eq!(::std::mem::size_of::() , 32usize , concat ! + ( "Size of: " , stringify ! ( kvm_memory_alias ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_memory_alias ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_alias ) ) . slot as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_alias ) , + "::" , stringify ! ( slot ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_alias ) ) . flags as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_alias ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_alias ) ) . guest_phys_addr as + * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_alias ) , + "::" , stringify ! ( guest_phys_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_alias ) ) . memory_size as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_alias ) , + "::" , stringify ! ( memory_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_alias ) ) . target_phys_addr + as * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_alias ) , + "::" , stringify ! ( target_phys_addr ) )); +} +impl Clone for kvm_memory_alias { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_pic_state { + pub last_irr: __u8, + pub irr: __u8, + pub imr: __u8, + pub isr: __u8, + pub priority_add: __u8, + pub irq_base: __u8, + pub read_reg_select: __u8, + pub poll: __u8, + pub special_mask: __u8, + pub init_state: __u8, + pub auto_eoi: __u8, + pub rotate_on_auto_eoi: __u8, + pub special_fully_nested_mode: __u8, + pub init4: __u8, + pub elcr: __u8, + pub elcr_mask: __u8, +} +#[test] +fn bindgen_test_layout_kvm_pic_state() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_pic_state ) )); + assert_eq! (::std::mem::align_of::() , 1usize , concat ! ( + "Alignment of " , stringify ! ( kvm_pic_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . last_irr as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( last_irr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . irr as * const _ as + usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( irr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . imr as * const _ as + usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( imr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . isr as * const _ as + usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( isr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . priority_add as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( priority_add ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . irq_base as * const _ + as usize } , 5usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( irq_base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . read_reg_select as * + const _ as usize } , 6usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( read_reg_select ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . poll as * const _ as + usize } , 7usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( poll ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . special_mask as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( special_mask ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . init_state as * const + _ as usize } , 9usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( init_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . auto_eoi as * const _ + as usize } , 10usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( auto_eoi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . rotate_on_auto_eoi as + * const _ as usize } , 11usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( rotate_on_auto_eoi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . + special_fully_nested_mode as * const _ as usize } , 12usize , + concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( special_fully_nested_mode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . init4 as * const _ as + usize } , 13usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( init4 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . elcr as * const _ as + usize } , 14usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( elcr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pic_state ) ) . elcr_mask as * const + _ as usize } , 15usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pic_state ) , "::" + , stringify ! ( elcr_mask ) )); +} +impl Clone for kvm_pic_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_ioapic_state { + pub base_address: __u64, + pub ioregsel: __u32, + pub id: __u32, + pub irr: __u32, + pub pad: __u32, + pub redirtbl: [kvm_ioapic_state__bindgen_ty_1; 24usize], +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_ioapic_state__bindgen_ty_1 { + pub bits: __u64, + pub fields: kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 { + pub vector: __u8, + pub _bitfield_1: u8, + pub _bitfield_2: u8, + pub _bitfield_3: u8, + pub reserved: [__u8; 4usize], + pub dest_id: __u8, +} +#[test] +fn bindgen_test_layout_kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() + , 8usize , concat ! ( + "Size of: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() + , 1usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 + ) ) . vector as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( vector ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 + ) ) . reserved as * const _ as usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( reserved ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 + ) ) . dest_id as * const _ as usize } , 7usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( dest_id ) )); +} +impl Clone for kvm_ioapic_state__bindgen_ty_1__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_ioapic_state__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_ioapic_state__bindgen_ty_1 ) + )); + assert_eq! (::std::mem::align_of::() , + 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_ioapic_state__bindgen_ty_1 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state__bindgen_ty_1 ) ) . bits + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1 ) , "::" , stringify ! ( bits ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state__bindgen_ty_1 ) ) . + fields as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ioapic_state__bindgen_ty_1 ) , "::" , stringify ! ( fields + ) )); +} +impl Clone for kvm_ioapic_state__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_ioapic_state() { + assert_eq!(::std::mem::size_of::() , 216usize , concat ! + ( "Size of: " , stringify ! ( kvm_ioapic_state ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_ioapic_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . base_address as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( base_address ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . ioregsel as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( ioregsel ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . id as * const _ as + usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . irr as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( irr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . pad as * const _ + as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioapic_state ) ) . redirtbl as * + const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioapic_state ) , + "::" , stringify ! ( redirtbl ) )); +} +impl Clone for kvm_ioapic_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_regs { + pub rax: __u64, + pub rbx: __u64, + pub rcx: __u64, + pub rdx: __u64, + pub rsi: __u64, + pub rdi: __u64, + pub rsp: __u64, + pub rbp: __u64, + pub r8: __u64, + pub r9: __u64, + pub r10: __u64, + pub r11: __u64, + pub r12: __u64, + pub r13: __u64, + pub r14: __u64, + pub r15: __u64, + pub rip: __u64, + pub rflags: __u64, +} + +impl kvm_regs { + pub fn empty() ->kvm_regs { + kvm_regs { + rax: 0,rbx: 0,rcx: 0, rdx: 0, rsi: 0,rdi:0, rsp: 0,rbp: 0, r8: 0, r9: 0,r10: 0, r11: 0, r12: 0,r13:0, r14: 0,r15: 0,rip: 0, rflags: 0 + } + } +} + +#[test] +fn bindgen_test_layout_kvm_regs() { + assert_eq!(::std::mem::size_of::() , 144usize , concat ! ( + "Size of: " , stringify ! ( kvm_regs ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_regs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rax as * const _ as usize + } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rax ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rbx as * const _ as usize + } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rbx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rcx as * const _ as usize + } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rcx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rdx as * const _ as usize + } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rdx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rsi as * const _ as usize + } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rsi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rdi as * const _ as usize + } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rdi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rsp as * const _ as usize + } , 48usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rsp ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rbp as * const _ as usize + } , 56usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rbp ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r8 as * const _ as usize } + , 64usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r8 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r9 as * const _ as usize } + , 72usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r9 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r10 as * const _ as usize + } , 80usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r10 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r11 as * const _ as usize + } , 88usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r11 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r12 as * const _ as usize + } , 96usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r12 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r13 as * const _ as usize + } , 104usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r13 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r14 as * const _ as usize + } , 112usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r14 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . r15 as * const _ as usize + } , 120usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( r15 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rip as * const _ as usize + } , 128usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_regs ) ) . rflags as * const _ as + usize } , 136usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_regs ) , "::" , + stringify ! ( rflags ) )); +} +impl Clone for kvm_regs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +pub struct kvm_lapic_state { + pub regs: [::std::os::raw::c_char; 1024usize], +} +#[test] +fn bindgen_test_layout_kvm_lapic_state() { + assert_eq!(::std::mem::size_of::() , 1024usize , concat ! + ( "Size of: " , stringify ! ( kvm_lapic_state ) )); + assert_eq! (::std::mem::align_of::() , 1usize , concat ! + ( "Alignment of " , stringify ! ( kvm_lapic_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_lapic_state ) ) . regs as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_lapic_state ) , + "::" , stringify ! ( regs ) )); +} +#[repr(C)] +#[derive(Default, Debug, Copy)] +pub struct kvm_segment { + pub base: __u64, + pub limit: __u32, + pub selector: __u16, + pub type_: __u8, + pub present: __u8, + pub dpl: __u8, + pub db: __u8, + pub s: __u8, + pub l: __u8, + pub g: __u8, + pub avl: __u8, + pub unusable: __u8, + pub padding: __u8, +} + +impl kvm_segment { + pub fn empty() -> kvm_segment { + kvm_segment { + base: 0, limit: 0, selector: 0, type_: 0, present: 0, dpl: 0, db: 0,s: 0, l: 0,g:0, avl: 0, unusable: 0, padding: 0 + } + } +} +#[test] +fn bindgen_test_layout_kvm_segment() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_segment ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_segment ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . base as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . limit as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( limit ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . selector as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( selector ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . type_ as * const _ as + usize } , 14usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . present as * const _ as + usize } , 15usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( present ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . dpl as * const _ as + usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( dpl ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . db as * const _ as + usize } , 17usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( db ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . s as * const _ as usize + } , 18usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( s ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . l as * const _ as usize + } , 19usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( l ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . g as * const _ as usize + } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( g ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . avl as * const _ as + usize } , 21usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( avl ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . unusable as * const _ + as usize } , 22usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( unusable ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_segment ) ) . padding as * const _ as + usize } , 23usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_segment ) , "::" , + stringify ! ( padding ) )); +} +impl Clone for kvm_segment { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Default, Debug, Copy)] +pub struct kvm_dtable { + pub base: __u64, + pub limit: __u16, + pub padding: [__u16; 3usize], +} +#[test] +fn bindgen_test_layout_kvm_dtable() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_dtable ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_dtable ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dtable ) ) . base as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dtable ) , "::" , + stringify ! ( base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dtable ) ) . limit as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dtable ) , "::" , + stringify ! ( limit ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dtable ) ) . padding as * const _ as + usize } , 10usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dtable ) , "::" , + stringify ! ( padding ) )); +} +impl Clone for kvm_dtable { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Default, Debug, Copy)] +pub struct kvm_sregs { + pub cs: kvm_segment, + pub ds: kvm_segment, + pub es: kvm_segment, + pub fs: kvm_segment, + pub gs: kvm_segment, + pub ss: kvm_segment, + pub tr: kvm_segment, + pub ldt: kvm_segment, + pub gdt: kvm_dtable, + pub idt: kvm_dtable, + pub cr0: __u64, + pub cr2: __u64, + pub cr3: __u64, + pub cr4: __u64, + pub cr8: __u64, + pub efer: __u64, + pub apic_base: __u64, + pub interrupt_bitmap: [__u64; 4usize], +} + +impl kvm_sregs { + pub fn empty() -> kvm_sregs { + kvm_sregs::default() + } +} + +#[test] +fn bindgen_test_layout_kvm_sregs() { + assert_eq!(::std::mem::size_of::() , 312usize , concat ! ( + "Size of: " , stringify ! ( kvm_sregs ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_sregs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cs as * const _ as usize + } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . ds as * const _ as usize + } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( ds ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . es as * const _ as usize + } , 48usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( es ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . fs as * const _ as usize + } , 72usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( fs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . gs as * const _ as usize + } , 96usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( gs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . ss as * const _ as usize + } , 120usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( ss ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . tr as * const _ as usize + } , 144usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( tr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . ldt as * const _ as usize + } , 168usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( ldt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . gdt as * const _ as usize + } , 192usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( gdt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . idt as * const _ as usize + } , 208usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( idt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cr0 as * const _ as usize + } , 224usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cr0 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cr2 as * const _ as usize + } , 232usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cr2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cr3 as * const _ as usize + } , 240usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cr3 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cr4 as * const _ as usize + } , 248usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cr4 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . cr8 as * const _ as usize + } , 256usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( cr8 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . efer as * const _ as + usize } , 264usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( efer ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . apic_base as * const _ as + usize } , 272usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( apic_base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_sregs ) ) . interrupt_bitmap as * + const _ as usize } , 280usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_sregs ) , "::" , + stringify ! ( interrupt_bitmap ) )); +} +impl Clone for kvm_sregs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_fpu { + pub fpr: [[__u8; 16usize]; 8usize], + pub fcw: __u16, + pub fsw: __u16, + pub ftwx: __u8, + pub pad1: __u8, + pub last_opcode: __u16, + pub last_ip: __u64, + pub last_dp: __u64, + pub xmm: [[__u8; 16usize]; 16usize], + pub mxcsr: __u32, + pub pad2: __u32, +} +#[test] +fn bindgen_test_layout_kvm_fpu() { + assert_eq!(::std::mem::size_of::() , 416usize , concat ! ( + "Size of: " , stringify ! ( kvm_fpu ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_fpu ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . fpr as * const _ as usize } + , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( fpr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . fcw as * const _ as usize } + , 128usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( fcw ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . fsw as * const _ as usize } + , 130usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( fsw ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . ftwx as * const _ as usize + } , 132usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( ftwx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . pad1 as * const _ as usize + } , 133usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( pad1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . last_opcode as * const _ as + usize } , 134usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( last_opcode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . last_ip as * const _ as + usize } , 136usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( last_ip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . last_dp as * const _ as + usize } , 144usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( last_dp ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . xmm as * const _ as usize } + , 152usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( xmm ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . mxcsr as * const _ as usize + } , 408usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( mxcsr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_fpu ) ) . pad2 as * const _ as usize + } , 412usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_fpu ) , "::" , + stringify ! ( pad2 ) )); +} +impl Clone for kvm_fpu { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_msr_entry { + pub index: __u32, + pub reserved: __u32, + pub data: __u64, +} +#[test] +fn bindgen_test_layout_kvm_msr_entry() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_msr_entry ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_msr_entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msr_entry ) ) . index as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msr_entry ) , "::" + , stringify ! ( index ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msr_entry ) ) . reserved as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msr_entry ) , "::" + , stringify ! ( reserved ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msr_entry ) ) . data as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msr_entry ) , "::" + , stringify ! ( data ) )); +} +impl Clone for kvm_msr_entry { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_msrs { + pub nmsrs: __u32, + pub pad: __u32, + pub entries: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_kvm_msrs() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_msrs ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_msrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msrs ) ) . nmsrs as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msrs ) , "::" , + stringify ! ( nmsrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msrs ) ) . pad as * const _ as usize + } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msrs ) , "::" , + stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msrs ) ) . entries as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msrs ) , "::" , + stringify ! ( entries ) )); +} +impl Clone for kvm_msrs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_msr_list { + pub nmsrs: __u32, + pub indices: __IncompleteArrayField<__u32>, +} +#[test] +fn bindgen_test_layout_kvm_msr_list() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( + "Size of: " , stringify ! ( kvm_msr_list ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_msr_list ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msr_list ) ) . nmsrs as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msr_list ) , "::" , + stringify ! ( nmsrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msr_list ) ) . indices as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msr_list ) , "::" , + stringify ! ( indices ) )); +} +impl Clone for kvm_msr_list { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_cpuid_entry { + pub function: __u32, + pub eax: __u32, + pub ebx: __u32, + pub ecx: __u32, + pub edx: __u32, + pub padding: __u32, +} +#[test] +fn bindgen_test_layout_kvm_cpuid_entry() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_cpuid_entry ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_cpuid_entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . function as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( function ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . eax as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( eax ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . ebx as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( ebx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . ecx as * const _ as + usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( ecx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . edx as * const _ as + usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( edx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry ) ) . padding as * const + _ as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry ) , + "::" , stringify ! ( padding ) )); +} +impl Clone for kvm_cpuid_entry { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_cpuid { + pub nent: __u32, + pub padding: __u32, + pub entries: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_kvm_cpuid() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_cpuid ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_cpuid ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid ) ) . nent as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid ) , "::" , + stringify ! ( nent ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid ) ) . padding as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid ) , "::" , + stringify ! ( padding ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid ) ) . entries as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid ) , "::" , + stringify ! ( entries ) )); +} +impl Clone for kvm_cpuid { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_cpuid_entry2 { + pub function: __u32, + pub index: __u32, + pub flags: __u32, + pub eax: __u32, + pub ebx: __u32, + pub ecx: __u32, + pub edx: __u32, + pub padding: [__u32; 3usize], +} + +impl kvm_cpuid_entry2 { + pub fn empty() -> kvm_cpuid_entry2 { + kvm_cpuid_entry2 { + function: 0, + index: 0, + flags: 0, + eax: 0, + ebx: 0, + ecx: 0, + edx: 0, + padding: [0; 3] + } + } +} + +#[test] +fn bindgen_test_layout_kvm_cpuid_entry2() { + assert_eq!(::std::mem::size_of::() , 40usize , concat ! + ( "Size of: " , stringify ! ( kvm_cpuid_entry2 ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_cpuid_entry2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . function as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( function ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . index as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( index ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . flags as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . eax as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( eax ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . ebx as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( ebx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . ecx as * const _ + as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( ecx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . edx as * const _ + as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( edx ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid_entry2 ) ) . padding as * const + _ as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid_entry2 ) , + "::" , stringify ! ( padding ) )); +} +impl Clone for kvm_cpuid_entry2 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_cpuid2 { + pub nent: __u32, + pub padding: __u32, + pub entries: [kvm_cpuid_entry2; 100] +} + +impl kvm_cpuid2 { + pub fn empty() -> kvm_cpuid2 { + kvm_cpuid2 { + nent: 100, + padding: 0, + entries: [kvm_cpuid_entry2::empty(); 100] + } + } +} + +#[test] +fn bindgen_test_layout_kvm_cpuid2() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_cpuid2 ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_cpuid2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid2 ) ) . nent as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid2 ) , "::" , + stringify ! ( nent ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid2 ) ) . padding as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid2 ) , "::" , + stringify ! ( padding ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_cpuid2 ) ) . entries as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_cpuid2 ) , "::" , + stringify ! ( entries ) )); +} +impl Clone for kvm_cpuid2 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_pit_channel_state { + pub count: __u32, + pub latched_count: __u16, + pub count_latched: __u8, + pub status_latched: __u8, + pub status: __u8, + pub read_state: __u8, + pub write_state: __u8, + pub write_latch: __u8, + pub rw_mode: __u8, + pub mode: __u8, + pub bcd: __u8, + pub gate: __u8, + pub count_load_time: __s64, +} +#[test] +fn bindgen_test_layout_kvm_pit_channel_state() { + assert_eq!(::std::mem::size_of::() , 24usize , + concat ! ( "Size of: " , stringify ! ( kvm_pit_channel_state ) + )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_pit_channel_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . count as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( count ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . latched_count + as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( latched_count ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . count_latched + as * const _ as usize } , 6usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( count_latched ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . + status_latched as * const _ as usize } , 7usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( status_latched ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . status as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( status ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . read_state as + * const _ as usize } , 9usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( read_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . write_state + as * const _ as usize } , 10usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( write_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . write_latch + as * const _ as usize } , 11usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( write_latch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . rw_mode as * + const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( rw_mode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . mode as * + const _ as usize } , 13usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( mode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . bcd as * + const _ as usize } , 14usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( bcd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . gate as * + const _ as usize } , 15usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( gate ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_channel_state ) ) . + count_load_time as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_channel_state ) + , "::" , stringify ! ( count_load_time ) )); +} +impl Clone for kvm_pit_channel_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_debug_exit_arch { + pub exception: __u32, + pub pad: __u32, + pub pc: __u64, + pub dr6: __u64, + pub dr7: __u64, +} +#[test] +fn bindgen_test_layout_kvm_debug_exit_arch() { + assert_eq!(::std::mem::size_of::() , 32usize , concat + ! ( "Size of: " , stringify ! ( kvm_debug_exit_arch ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_debug_exit_arch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_exit_arch ) ) . exception as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_exit_arch ) , + "::" , stringify ! ( exception ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_exit_arch ) ) . pad as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_exit_arch ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_exit_arch ) ) . pc as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_exit_arch ) , + "::" , stringify ! ( pc ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_exit_arch ) ) . dr6 as * const + _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_exit_arch ) , + "::" , stringify ! ( dr6 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_exit_arch ) ) . dr7 as * const + _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_exit_arch ) , + "::" , stringify ! ( dr7 ) )); +} +impl Clone for kvm_debug_exit_arch { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_guest_debug_arch { + pub debugreg: [__u64; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_guest_debug_arch() { + assert_eq!(::std::mem::size_of::() , 64usize , + concat ! ( "Size of: " , stringify ! ( kvm_guest_debug_arch ) + )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_guest_debug_arch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_guest_debug_arch ) ) . debugreg as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_guest_debug_arch ) + , "::" , stringify ! ( debugreg ) )); +} +impl Clone for kvm_guest_debug_arch { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_pit_state { + pub channels: [kvm_pit_channel_state; 3usize], +} +#[test] +fn bindgen_test_layout_kvm_pit_state() { + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( + "Size of: " , stringify ! ( kvm_pit_state ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_pit_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_state ) ) . channels as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_state ) , "::" + , stringify ! ( channels ) )); +} +impl Clone for kvm_pit_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_pit_state2 { + pub channels: [kvm_pit_channel_state; 3usize], + pub flags: __u32, + pub reserved: [__u32; 9usize], +} +#[test] +fn bindgen_test_layout_kvm_pit_state2() { + assert_eq!(::std::mem::size_of::() , 112usize , concat ! ( + "Size of: " , stringify ! ( kvm_pit_state2 ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_pit_state2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_state2 ) ) . channels as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_state2 ) , "::" + , stringify ! ( channels ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_state2 ) ) . flags as * const _ + as usize } , 72usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_state2 ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_state2 ) ) . reserved as * const + _ as usize } , 76usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_state2 ) , "::" + , stringify ! ( reserved ) )); +} +impl Clone for kvm_pit_state2 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_reinject_control { + pub pit_reinject: __u8, + pub reserved: [__u8; 31usize], +} +#[test] +fn bindgen_test_layout_kvm_reinject_control() { + assert_eq!(::std::mem::size_of::() , 32usize , + concat ! ( "Size of: " , stringify ! ( kvm_reinject_control ) + )); + assert_eq! (::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_reinject_control ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_reinject_control ) ) . pit_reinject + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_reinject_control ) + , "::" , stringify ! ( pit_reinject ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_reinject_control ) ) . reserved as * + const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_reinject_control ) + , "::" , stringify ! ( reserved ) )); +} +impl Clone for kvm_reinject_control { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vcpu_events { + pub exception: kvm_vcpu_events__bindgen_ty_1, + pub interrupt: kvm_vcpu_events__bindgen_ty_2, + pub nmi: kvm_vcpu_events__bindgen_ty_3, + pub sipi_vector: __u32, + pub flags: __u32, + pub smi: kvm_vcpu_events__bindgen_ty_4, + pub reserved: [__u32; 9usize], +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vcpu_events__bindgen_ty_1 { + pub injected: __u8, + pub nr: __u8, + pub has_error_code: __u8, + pub pad: __u8, + pub error_code: __u32, +} +#[test] +fn bindgen_test_layout_kvm_vcpu_events__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 8usize + , concat ! ( + "Size of: " , stringify ! ( kvm_vcpu_events__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , + 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_vcpu_events__bindgen_ty_1 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_1 ) ) . + injected as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_1 ) , "::" , stringify ! ( + injected ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_1 ) ) . nr as + * const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_1 ) , "::" , stringify ! ( nr ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_1 ) ) . + has_error_code as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_1 ) , "::" , stringify ! ( + has_error_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_1 ) ) . pad + as * const _ as usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_1 ) , "::" , stringify ! ( pad ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_1 ) ) . + error_code as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_1 ) , "::" , stringify ! ( + error_code ) )); +} +impl Clone for kvm_vcpu_events__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vcpu_events__bindgen_ty_2 { + pub injected: __u8, + pub nr: __u8, + pub soft: __u8, + pub shadow: __u8, +} +#[test] +fn bindgen_test_layout_kvm_vcpu_events__bindgen_ty_2() { + assert_eq!(::std::mem::size_of::() , 4usize + , concat ! ( + "Size of: " , stringify ! ( kvm_vcpu_events__bindgen_ty_2 ) )); + assert_eq! (::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of " , stringify ! ( kvm_vcpu_events__bindgen_ty_2 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_2 ) ) . + injected as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_2 ) , "::" , stringify ! ( + injected ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_2 ) ) . nr as + * const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_2 ) , "::" , stringify ! ( nr ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_2 ) ) . soft + as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_2 ) , "::" , stringify ! ( soft ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_2 ) ) . + shadow as * const _ as usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_2 ) , "::" , stringify ! ( shadow + ) )); +} +impl Clone for kvm_vcpu_events__bindgen_ty_2 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vcpu_events__bindgen_ty_3 { + pub injected: __u8, + pub pending: __u8, + pub masked: __u8, + pub pad: __u8, +} +#[test] +fn bindgen_test_layout_kvm_vcpu_events__bindgen_ty_3() { + assert_eq!(::std::mem::size_of::() , 4usize + , concat ! ( + "Size of: " , stringify ! ( kvm_vcpu_events__bindgen_ty_3 ) )); + assert_eq! (::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of " , stringify ! ( kvm_vcpu_events__bindgen_ty_3 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_3 ) ) . + injected as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_3 ) , "::" , stringify ! ( + injected ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_3 ) ) . + pending as * const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_3 ) , "::" , stringify ! ( pending + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_3 ) ) . + masked as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_3 ) , "::" , stringify ! ( masked + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_3 ) ) . pad + as * const _ as usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_3 ) , "::" , stringify ! ( pad ) + )); +} +impl Clone for kvm_vcpu_events__bindgen_ty_3 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vcpu_events__bindgen_ty_4 { + pub smm: __u8, + pub pending: __u8, + pub smm_inside_nmi: __u8, + pub latched_init: __u8, +} +#[test] +fn bindgen_test_layout_kvm_vcpu_events__bindgen_ty_4() { + assert_eq!(::std::mem::size_of::() , 4usize + , concat ! ( + "Size of: " , stringify ! ( kvm_vcpu_events__bindgen_ty_4 ) )); + assert_eq! (::std::mem::align_of::() , + 1usize , concat ! ( + "Alignment of " , stringify ! ( kvm_vcpu_events__bindgen_ty_4 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_4 ) ) . smm + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_4 ) , "::" , stringify ! ( smm ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_4 ) ) . + pending as * const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_4 ) , "::" , stringify ! ( pending + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_4 ) ) . + smm_inside_nmi as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_4 ) , "::" , stringify ! ( + smm_inside_nmi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events__bindgen_ty_4 ) ) . + latched_init as * const _ as usize } , 3usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_vcpu_events__bindgen_ty_4 ) , "::" , stringify ! ( + latched_init ) )); +} +impl Clone for kvm_vcpu_events__bindgen_ty_4 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_vcpu_events() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_vcpu_events ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_vcpu_events ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . exception as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( exception ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . interrupt as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( interrupt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . nmi as * const _ as + usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( nmi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . sipi_vector as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( sipi_vector ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . flags as * const _ + as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . smi as * const _ as + usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( smi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vcpu_events ) ) . reserved as * const + _ as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vcpu_events ) , + "::" , stringify ! ( reserved ) )); +} +impl Clone for kvm_vcpu_events { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_debugregs { + pub db: [__u64; 4usize], + pub dr6: __u64, + pub dr7: __u64, + pub flags: __u64, + pub reserved: [__u64; 9usize], +} +#[test] +fn bindgen_test_layout_kvm_debugregs() { + assert_eq!(::std::mem::size_of::() , 128usize , concat ! ( + "Size of: " , stringify ! ( kvm_debugregs ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_debugregs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debugregs ) ) . db as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debugregs ) , "::" + , stringify ! ( db ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debugregs ) ) . dr6 as * const _ as + usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debugregs ) , "::" + , stringify ! ( dr6 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debugregs ) ) . dr7 as * const _ as + usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debugregs ) , "::" + , stringify ! ( dr7 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debugregs ) ) . flags as * const _ as + usize } , 48usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debugregs ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debugregs ) ) . reserved as * const _ + as usize } , 56usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debugregs ) , "::" + , stringify ! ( reserved ) )); +} +impl Clone for kvm_debugregs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +pub struct kvm_xsave { + pub region: [__u32; 1024usize], +} +#[test] +fn bindgen_test_layout_kvm_xsave() { + assert_eq!(::std::mem::size_of::() , 4096usize , concat ! ( + "Size of: " , stringify ! ( kvm_xsave ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_xsave ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xsave ) ) . region as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xsave ) , "::" , + stringify ! ( region ) )); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_xcr { + pub xcr: __u32, + pub reserved: __u32, + pub value: __u64, +} +#[test] +fn bindgen_test_layout_kvm_xcr() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_xcr ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_xcr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcr ) ) . xcr as * const _ as usize } + , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcr ) , "::" , + stringify ! ( xcr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcr ) ) . reserved as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcr ) , "::" , + stringify ! ( reserved ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcr ) ) . value as * const _ as usize + } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcr ) , "::" , + stringify ! ( value ) )); +} +impl Clone for kvm_xcr { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_xcrs { + pub nr_xcrs: __u32, + pub flags: __u32, + pub xcrs: [kvm_xcr; 16usize], + pub padding: [__u64; 16usize], +} +#[test] +fn bindgen_test_layout_kvm_xcrs() { + assert_eq!(::std::mem::size_of::() , 392usize , concat ! ( + "Size of: " , stringify ! ( kvm_xcrs ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_xcrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcrs ) ) . nr_xcrs as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcrs ) , "::" , + stringify ! ( nr_xcrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcrs ) ) . flags as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcrs ) , "::" , + stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcrs ) ) . xcrs as * const _ as usize + } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcrs ) , "::" , + stringify ! ( xcrs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xcrs ) ) . padding as * const _ as + usize } , 264usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xcrs ) , "::" , + stringify ! ( padding ) )); +} +impl Clone for kvm_xcrs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_sync_regs { + pub _address: u8, +} +#[test] +fn bindgen_test_layout_kvm_sync_regs() { + assert_eq!(::std::mem::size_of::() , 0usize , concat ! ( + "Size of: " , stringify ! ( kvm_sync_regs ) )); + assert_eq! (::std::mem::align_of::() , 1usize , concat ! ( + "Alignment of " , stringify ! ( kvm_sync_regs ) )); +} +impl Clone for kvm_sync_regs { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_user_trace_setup { + pub buf_size: __u32, + pub buf_nr: __u32, +} +#[test] +fn bindgen_test_layout_kvm_user_trace_setup() { + assert_eq!(::std::mem::size_of::() , 8usize , concat + ! ( "Size of: " , stringify ! ( kvm_user_trace_setup ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_user_trace_setup ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_user_trace_setup ) ) . buf_size as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_user_trace_setup ) + , "::" , stringify ! ( buf_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_user_trace_setup ) ) . buf_nr as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_user_trace_setup ) + , "::" , stringify ! ( buf_nr ) )); +} +impl Clone for kvm_user_trace_setup { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_breakpoint { + pub enabled: __u32, + pub padding: __u32, + pub address: __u64, +} +#[test] +fn bindgen_test_layout_kvm_breakpoint() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_breakpoint ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_breakpoint ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_breakpoint ) ) . enabled as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_breakpoint ) , "::" + , stringify ! ( enabled ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_breakpoint ) ) . padding as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_breakpoint ) , "::" + , stringify ! ( padding ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_breakpoint ) ) . address as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_breakpoint ) , "::" + , stringify ! ( address ) )); +} +impl Clone for kvm_breakpoint { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_debug_guest { + pub enabled: __u32, + pub pad: __u32, + pub breakpoints: [kvm_breakpoint; 4usize], + pub singlestep: __u32, +} +#[test] +fn bindgen_test_layout_kvm_debug_guest() { + assert_eq!(::std::mem::size_of::() , 80usize , concat ! ( + "Size of: " , stringify ! ( kvm_debug_guest ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_debug_guest ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_guest ) ) . enabled as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_guest ) , + "::" , stringify ! ( enabled ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_guest ) ) . pad as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_guest ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_guest ) ) . breakpoints as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_guest ) , + "::" , stringify ! ( breakpoints ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_debug_guest ) ) . singlestep as * + const _ as usize } , 72usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_debug_guest ) , + "::" , stringify ! ( singlestep ) )); +} +impl Clone for kvm_debug_guest { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_memory_region { + pub slot: __u32, + pub flags: __u32, + pub guest_phys_addr: __u64, + pub memory_size: __u64, +} +#[test] +fn bindgen_test_layout_kvm_memory_region() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! + ( "Size of: " , stringify ! ( kvm_memory_region ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_memory_region ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_region ) ) . slot as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_region ) , + "::" , stringify ! ( slot ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_region ) ) . flags as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_region ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_region ) ) . guest_phys_addr + as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_region ) , + "::" , stringify ! ( guest_phys_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_memory_region ) ) . memory_size as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_memory_region ) , + "::" , stringify ! ( memory_size ) )); +} +impl Clone for kvm_memory_region { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_userspace_memory_region { + pub slot: __u32, + pub flags: __u32, + pub guest_phys_addr: __u64, + pub memory_size: __u64, + pub userspace_addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_userspace_memory_region() { + assert_eq!(::std::mem::size_of::() , 32usize + , concat ! ( + "Size of: " , stringify ! ( kvm_userspace_memory_region ) )); + assert_eq! (::std::mem::align_of::() , 8usize + , concat ! ( + "Alignment of " , stringify ! ( kvm_userspace_memory_region ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_userspace_memory_region ) ) . slot as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_userspace_memory_region ) , "::" , stringify ! ( slot ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_userspace_memory_region ) ) . flags + as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_userspace_memory_region ) , "::" , stringify ! ( flags ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_userspace_memory_region ) ) . + guest_phys_addr as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_userspace_memory_region ) , "::" , stringify ! ( + guest_phys_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_userspace_memory_region ) ) . + memory_size as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_userspace_memory_region ) , "::" , stringify ! ( + memory_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_userspace_memory_region ) ) . + userspace_addr as * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_userspace_memory_region ) , "::" , stringify ! ( + userspace_addr ) )); +} +impl Clone for kvm_userspace_memory_region { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_irq_level { + pub __bindgen_anon_1: kvm_irq_level__bindgen_ty_1, + pub level: __u32, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_irq_level__bindgen_ty_1 { + pub irq: __u32, + pub status: __s32, +} +#[test] +fn bindgen_test_layout_kvm_irq_level__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 4usize , + concat ! ( + "Size of: " , stringify ! ( kvm_irq_level__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , 4usize + , concat ! ( + "Alignment of " , stringify ! ( kvm_irq_level__bindgen_ty_1 ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_level__bindgen_ty_1 ) ) . irq as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_level__bindgen_ty_1 ) , "::" , stringify ! ( irq ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_level__bindgen_ty_1 ) ) . status + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_level__bindgen_ty_1 ) , "::" , stringify ! ( status ) + )); +} +impl Clone for kvm_irq_level__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_irq_level() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_irq_level ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_irq_level ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_level ) ) . level as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_level ) , "::" + , stringify ! ( level ) )); +} +impl Clone for kvm_irq_level { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +pub struct kvm_irqchip { + pub chip_id: __u32, + pub pad: __u32, + pub chip: kvm_irqchip__bindgen_ty_1, +} +#[repr(C)] +pub union kvm_irqchip__bindgen_ty_1 { + pub dummy: [::std::os::raw::c_char; 512usize], + pub pic: kvm_pic_state, + pub ioapic: kvm_ioapic_state, +} +#[test] +fn bindgen_test_layout_kvm_irqchip__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 512usize , + concat ! ( + "Size of: " , stringify ! ( kvm_irqchip__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_irqchip__bindgen_ty_1 ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip__bindgen_ty_1 ) ) . dummy as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irqchip__bindgen_ty_1 ) , "::" , stringify ! ( dummy ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip__bindgen_ty_1 ) ) . pic as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irqchip__bindgen_ty_1 ) , "::" , stringify ! ( pic ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip__bindgen_ty_1 ) ) . ioapic as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irqchip__bindgen_ty_1 ) , "::" , stringify ! ( ioapic ) + )); +} +#[test] +fn bindgen_test_layout_kvm_irqchip() { + assert_eq!(::std::mem::size_of::() , 520usize , concat ! ( + "Size of: " , stringify ! ( kvm_irqchip ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_irqchip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip ) ) . chip_id as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqchip ) , "::" , + stringify ! ( chip_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip ) ) . pad as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqchip ) , "::" , + stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqchip ) ) . chip as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqchip ) , "::" , + stringify ! ( chip ) )); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_pit_config { + pub flags: __u32, + pub pad: [__u32; 15usize], +} +#[test] +fn bindgen_test_layout_kvm_pit_config() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_pit_config ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_pit_config ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_config ) ) . flags as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_config ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_pit_config ) ) . pad as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_pit_config ) , "::" + , stringify ! ( pad ) )); +} +impl Clone for kvm_pit_config { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_skeys { + pub start_gfn: __u64, + pub count: __u64, + pub skeydata_addr: __u64, + pub flags: __u32, + pub reserved: [__u32; 9usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_skeys() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_s390_skeys ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_s390_skeys ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_skeys ) ) . start_gfn as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_skeys ) , "::" + , stringify ! ( start_gfn ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_skeys ) ) . count as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_skeys ) , "::" + , stringify ! ( count ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_skeys ) ) . skeydata_addr as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_skeys ) , "::" + , stringify ! ( skeydata_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_skeys ) ) . flags as * const _ + as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_skeys ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_skeys ) ) . reserved as * const + _ as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_skeys ) , "::" + , stringify ! ( reserved ) )); +} +impl Clone for kvm_s390_skeys { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_hyperv_exit { + pub type_: __u32, + pub u: kvm_hyperv_exit__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_hyperv_exit__bindgen_ty_1 { + pub synic: kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1, + pub hcall: kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 { + pub msr: __u32, + pub control: __u64, + pub evt_page: __u64, + pub msg_page: __u64, +} +#[test] +fn bindgen_test_layout_kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() + , 32usize , concat ! ( + "Size of: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) + ) . msr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( msr ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) + ) . control as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( control ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) + ) . evt_page as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( evt_page ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) + ) . msg_page as * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 ) , "::" , + stringify ! ( msg_page ) )); +} +impl Clone for kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 { + pub input: __u64, + pub result: __u64, + pub params: [__u64; 2usize], +} +#[test] +fn bindgen_test_layout_kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2() { + assert_eq!(::std::mem::size_of::() + , 32usize , concat ! ( + "Size of: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) + ) . input as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) , "::" , + stringify ! ( input ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) + ) . result as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) , "::" , + stringify ! ( result ) )); + assert_eq! (unsafe { + & ( + * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) + ) . params as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 ) , "::" , + stringify ! ( params ) )); +} +impl Clone for kvm_hyperv_exit__bindgen_ty_1__bindgen_ty_2 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_hyperv_exit__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 32usize , concat ! ( + "Size of: " , stringify ! ( kvm_hyperv_exit__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , + 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_hyperv_exit__bindgen_ty_1 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1 ) ) . synic + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1 ) , "::" , stringify ! ( synic ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_hyperv_exit__bindgen_ty_1 ) ) . hcall + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_hyperv_exit__bindgen_ty_1 ) , "::" , stringify ! ( hcall ) + )); +} +impl Clone for kvm_hyperv_exit__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_hyperv_exit() { + assert_eq!(::std::mem::size_of::() , 40usize , concat ! ( + "Size of: " , stringify ! ( kvm_hyperv_exit ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_hyperv_exit ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_hyperv_exit ) ) . type_ as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_hyperv_exit ) , + "::" , stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_hyperv_exit ) ) . u as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_hyperv_exit ) , + "::" , stringify ! ( u ) )); +} +impl Clone for kvm_hyperv_exit { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +pub struct kvm_run { + pub request_interrupt_window: __u8, + pub padding1: [__u8; 7usize], + pub exit_reason: __u32, + pub ready_for_interrupt_injection: __u8, + pub if_flag: __u8, + pub flags: __u16, + pub cr8: __u64, + pub apic_base: __u64, + pub __bindgen_anon_1: kvm_run__bindgen_ty_1, + pub kvm_valid_regs: __u64, + pub kvm_dirty_regs: __u64, + pub s: kvm_run__bindgen_ty_2, +} +#[repr(C)] +pub union kvm_run__bindgen_ty_1 { + pub hw: kvm_run__bindgen_ty_1__bindgen_ty_1, + pub fail_entry: kvm_run__bindgen_ty_1__bindgen_ty_2, + pub ex: kvm_run__bindgen_ty_1__bindgen_ty_3, + pub io: kvm_run__bindgen_ty_1__bindgen_ty_4, + pub debug: kvm_run__bindgen_ty_1__bindgen_ty_5, + pub mmio: kvm_run__bindgen_ty_1__bindgen_ty_6, + pub hypercall: kvm_run__bindgen_ty_1__bindgen_ty_7, + pub tpr_access: kvm_run__bindgen_ty_1__bindgen_ty_8, + pub s390_sieic: kvm_run__bindgen_ty_1__bindgen_ty_9, + pub s390_reset_flags: __u64, + pub s390_ucontrol: kvm_run__bindgen_ty_1__bindgen_ty_10, + pub dcr: kvm_run__bindgen_ty_1__bindgen_ty_11, + pub internal: kvm_run__bindgen_ty_1__bindgen_ty_12, + pub osi: kvm_run__bindgen_ty_1__bindgen_ty_13, + pub papr_hcall: kvm_run__bindgen_ty_1__bindgen_ty_14, + pub s390_tsch: kvm_run__bindgen_ty_1__bindgen_ty_15, + pub epr: kvm_run__bindgen_ty_1__bindgen_ty_16, + pub system_event: kvm_run__bindgen_ty_1__bindgen_ty_17, + pub s390_stsi: kvm_run__bindgen_ty_1__bindgen_ty_18, + pub eoi: kvm_run__bindgen_ty_1__bindgen_ty_19, + pub hyperv: kvm_hyperv_exit, + pub padding: [::std::os::raw::c_char; 256usize], +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_1 { + pub hardware_exit_reason: __u64, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_1 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_1 ) ) . + hardware_exit_reason as * const _ as usize } , 0usize , concat + ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_1 ) , "::" , stringify ! ( + hardware_exit_reason ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_2 { + pub hardware_entry_failure_reason: __u64, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_2() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_2 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_2 ) ) . + hardware_entry_failure_reason as * const _ as usize } , 0usize + , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_2 ) , "::" , stringify ! ( + hardware_entry_failure_reason ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_2 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_3 { + pub exception: __u32, + pub error_code: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_3() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_3 + ) )); + assert_eq! (::std::mem::align_of::() + , 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_3 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_3 ) ) . + exception as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_3 ) , "::" , stringify ! ( + exception ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_3 ) ) . + error_code as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_3 ) , "::" , stringify ! ( + error_code ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_3 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_4 { + pub direction: __u8, + pub size: __u8, + pub port: __u16, + pub count: __u32, + pub data_offset: __u64, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_4() { + assert_eq!(::std::mem::size_of::() , + 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_4 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_4 ) ) . + direction as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) , "::" , stringify ! ( + direction ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_4 ) ) . + size as * const _ as usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) , "::" , stringify ! ( + size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_4 ) ) . + port as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) , "::" , stringify ! ( + port ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_4 ) ) . + count as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) , "::" , stringify ! ( + count ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_4 ) ) . + data_offset as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_4 ) , "::" , stringify ! ( + data_offset ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_4 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_5 { + pub arch: kvm_debug_exit_arch, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_5() { + assert_eq!(::std::mem::size_of::() , + 32usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_5 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_5 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_5 ) ) . + arch as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_5 ) , "::" , stringify ! ( + arch ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_5 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_6 { + pub phys_addr: __u64, + pub data: [__u8; 8usize], + pub len: __u32, + pub is_write: __u8, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_6() { + assert_eq!(::std::mem::size_of::() , + 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_6 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_6 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_6 ) ) . + phys_addr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_6 ) , "::" , stringify ! ( + phys_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_6 ) ) . + data as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_6 ) , "::" , stringify ! ( + data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_6 ) ) . + len as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_6 ) , "::" , stringify ! ( + len ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_6 ) ) . + is_write as * const _ as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_6 ) , "::" , stringify ! ( + is_write ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_6 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_7 { + pub nr: __u64, + pub args: [__u64; 6usize], + pub ret: __u64, + pub longmode: __u32, + pub pad: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_7() { + assert_eq!(::std::mem::size_of::() , + 72usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_7 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_7 ) ) . + nr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) , "::" , stringify ! ( + nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_7 ) ) . + args as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) , "::" , stringify ! ( + args ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_7 ) ) . + ret as * const _ as usize } , 56usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) , "::" , stringify ! ( + ret ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_7 ) ) . + longmode as * const _ as usize } , 64usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) , "::" , stringify ! ( + longmode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_7 ) ) . + pad as * const _ as usize } , 68usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_7 ) , "::" , stringify ! ( + pad ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_7 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_8 { + pub rip: __u64, + pub is_write: __u32, + pub pad: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_8() { + assert_eq!(::std::mem::size_of::() , + 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_8 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_8 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_8 ) ) . + rip as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_8 ) , "::" , stringify ! ( + rip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_8 ) ) . + is_write as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_8 ) , "::" , stringify ! ( + is_write ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_8 ) ) . + pad as * const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_8 ) , "::" , stringify ! ( + pad ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_8 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_9 { + pub icptcode: __u8, + pub ipa: __u16, + pub ipb: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_9() { + assert_eq!(::std::mem::size_of::() , + 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_run__bindgen_ty_1__bindgen_ty_9 + ) )); + assert_eq! (::std::mem::align_of::() + , 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_9 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_9 ) ) . + icptcode as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_9 ) , "::" , stringify ! ( + icptcode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_9 ) ) . + ipa as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_9 ) , "::" , stringify ! ( + ipa ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_9 ) ) . + ipb as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_9 ) , "::" , stringify ! ( + ipb ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_9 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_10 { + pub trans_exc_code: __u64, + pub pgm_code: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_10() { + assert_eq!(::std::mem::size_of::() , + 16usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_10 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_10 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_10 ) ) + . trans_exc_code as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_10 ) , "::" , stringify ! ( + trans_exc_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_10 ) ) + . pgm_code as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_10 ) , "::" , stringify ! ( + pgm_code ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_10 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_11 { + pub dcrn: __u32, + pub data: __u32, + pub is_write: __u8, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_11() { + assert_eq!(::std::mem::size_of::() , + 12usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_11 ) )); + assert_eq! (::std::mem::align_of::() + , 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_11 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_11 ) ) + . dcrn as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_11 ) , "::" , stringify ! ( + dcrn ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_11 ) ) + . data as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_11 ) , "::" , stringify ! ( + data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_11 ) ) + . is_write as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_11 ) , "::" , stringify ! ( + is_write ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_11 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_12 { + pub suberror: __u32, + pub ndata: __u32, + pub data: [__u64; 16usize], +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_12() { + assert_eq!(::std::mem::size_of::() , + 136usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_12 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_12 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_12 ) ) + . suberror as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_12 ) , "::" , stringify ! ( + suberror ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_12 ) ) + . ndata as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_12 ) , "::" , stringify ! ( + ndata ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_12 ) ) + . data as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_12 ) , "::" , stringify ! ( + data ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_12 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_13 { + pub gprs: [__u64; 32usize], +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_13() { + assert_eq!(::std::mem::size_of::() , + 256usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_13 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_13 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_13 ) ) + . gprs as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_13 ) , "::" , stringify ! ( + gprs ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_13 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_14 { + pub nr: __u64, + pub ret: __u64, + pub args: [__u64; 9usize], +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_14() { + assert_eq!(::std::mem::size_of::() , + 88usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_14 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_14 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_14 ) ) + . nr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_14 ) , "::" , stringify ! ( + nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_14 ) ) + . ret as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_14 ) , "::" , stringify ! ( + ret ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_14 ) ) + . args as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_14 ) , "::" , stringify ! ( + args ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_14 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_15 { + pub subchannel_id: __u16, + pub subchannel_nr: __u16, + pub io_int_parm: __u32, + pub io_int_word: __u32, + pub ipb: __u32, + pub dequeued: __u8, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_15() { + assert_eq!(::std::mem::size_of::() , + 20usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) )); + assert_eq! (::std::mem::align_of::() + , 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . subchannel_id as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + subchannel_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . subchannel_nr as * const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + subchannel_nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . io_int_parm as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + io_int_parm ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . io_int_word as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + io_int_word ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . ipb as * const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + ipb ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_15 ) ) + . dequeued as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_15 ) , "::" , stringify ! ( + dequeued ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_15 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_16 { + pub epr: __u32, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_16() { + assert_eq!(::std::mem::size_of::() , + 4usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_16 ) )); + assert_eq! (::std::mem::align_of::() + , 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_16 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_16 ) ) + . epr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_16 ) , "::" , stringify ! ( + epr ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_16 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_17 { + pub type_: __u32, + pub flags: __u64, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_17() { + assert_eq!(::std::mem::size_of::() , + 16usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_17 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_17 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_17 ) ) + . type_ as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_17 ) , "::" , stringify ! ( + type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_17 ) ) + . flags as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_17 ) , "::" , stringify ! ( + flags ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_17 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_18 { + pub addr: __u64, + pub ar: __u8, + pub reserved: __u8, + pub fc: __u8, + pub sel1: __u8, + pub sel2: __u16, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_18() { + assert_eq!(::std::mem::size_of::() , + 16usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . addr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . ar as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + ar ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . reserved as * const _ as usize } , 9usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + reserved ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . fc as * const _ as usize } , 10usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + fc ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . sel1 as * const _ as usize } , 11usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + sel1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_18 ) ) + . sel2 as * const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_18 ) , "::" , stringify ! ( + sel2 ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_18 { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_run__bindgen_ty_1__bindgen_ty_19 { + pub vector: __u8, +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1__bindgen_ty_19() { + assert_eq!(::std::mem::size_of::() , + 1usize , concat ! ( + "Size of: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_19 ) )); + assert_eq! (::std::mem::align_of::() + , 1usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_19 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1__bindgen_ty_19 ) ) + . vector as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_run__bindgen_ty_1__bindgen_ty_19 ) , "::" , stringify ! ( + vector ) )); +} +impl Clone for kvm_run__bindgen_ty_1__bindgen_ty_19 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 256usize , + concat ! ( "Size of: " , stringify ! ( kvm_run__bindgen_ty_1 ) + )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_run__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . hw as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( hw ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . fail_entry as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( fail_entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . ex as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( ex ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . io as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( io ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . debug as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( debug ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . mmio as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( mmio ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . hypercall as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( hypercall ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . tpr_access as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( tpr_access ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . s390_sieic as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( s390_sieic ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . + s390_reset_flags as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( s390_reset_flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . s390_ucontrol + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( s390_ucontrol ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . dcr as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( dcr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . internal as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( internal ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . osi as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( osi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . papr_hcall as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( papr_hcall ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . s390_tsch as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( s390_tsch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . epr as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( epr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . system_event + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( system_event ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . s390_stsi as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( s390_stsi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . eoi as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( eoi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . hyperv as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( hyperv ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_1 ) ) . padding as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_1 ) + , "::" , stringify ! ( padding ) )); +} +#[repr(C)] +pub union kvm_run__bindgen_ty_2 { + pub regs: kvm_sync_regs, + pub padding: [::std::os::raw::c_char; 2048usize], +} +#[test] +fn bindgen_test_layout_kvm_run__bindgen_ty_2() { + assert_eq!(::std::mem::size_of::() , 2048usize , + concat ! ( "Size of: " , stringify ! ( kvm_run__bindgen_ty_2 ) + )); + assert_eq! (::std::mem::align_of::() , 1usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_run__bindgen_ty_2 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_2 ) ) . regs as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_2 ) + , "::" , stringify ! ( regs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run__bindgen_ty_2 ) ) . padding as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run__bindgen_ty_2 ) + , "::" , stringify ! ( padding ) )); +} +#[test] +fn bindgen_test_layout_kvm_run() { + assert_eq!(::std::mem::size_of::() , 2352usize , concat ! ( + "Size of: " , stringify ! ( kvm_run ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_run ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . request_interrupt_window as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( request_interrupt_window ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . padding1 as * const _ as + usize } , 1usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( padding1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . exit_reason as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( exit_reason ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . + ready_for_interrupt_injection as * const _ as usize } , + 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( ready_for_interrupt_injection ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . if_flag as * const _ as + usize } , 13usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( if_flag ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . flags as * const _ as usize + } , 14usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . cr8 as * const _ as usize } + , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( cr8 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . apic_base as * const _ as + usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( apic_base ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . kvm_valid_regs as * const _ + as usize } , 288usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( kvm_valid_regs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . kvm_dirty_regs as * const _ + as usize } , 296usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( kvm_dirty_regs ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_run ) ) . s as * const _ as usize } , + 304usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_run ) , "::" , + stringify ! ( s ) )); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_coalesced_mmio_zone { + pub addr: __u64, + pub size: __u32, + pub pad: __u32, +} +#[test] +fn bindgen_test_layout_kvm_coalesced_mmio_zone() { + assert_eq!(::std::mem::size_of::() , 16usize , + concat ! ( + "Size of: " , stringify ! ( kvm_coalesced_mmio_zone ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_coalesced_mmio_zone ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_zone ) ) . addr as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_zone + ) , "::" , stringify ! ( addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_zone ) ) . size as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_zone + ) , "::" , stringify ! ( size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_zone ) ) . pad as * + const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_zone + ) , "::" , stringify ! ( pad ) )); +} +impl Clone for kvm_coalesced_mmio_zone { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_coalesced_mmio { + pub phys_addr: __u64, + pub len: __u32, + pub pad: __u32, + pub data: [__u8; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_coalesced_mmio() { + assert_eq!(::std::mem::size_of::() , 24usize , concat + ! ( "Size of: " , stringify ! ( kvm_coalesced_mmio ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_coalesced_mmio ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio ) ) . phys_addr as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio ) , + "::" , stringify ! ( phys_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio ) ) . len as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio ) , + "::" , stringify ! ( len ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio ) ) . pad as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio ) ) . data as * const + _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio ) , + "::" , stringify ! ( data ) )); +} +impl Clone for kvm_coalesced_mmio { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_coalesced_mmio_ring { + pub first: __u32, + pub last: __u32, + pub coalesced_mmio: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_kvm_coalesced_mmio_ring() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( + "Size of: " , stringify ! ( kvm_coalesced_mmio_ring ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_coalesced_mmio_ring ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_ring ) ) . first as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_ring + ) , "::" , stringify ! ( first ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_ring ) ) . last as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_ring + ) , "::" , stringify ! ( last ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_coalesced_mmio_ring ) ) . + coalesced_mmio as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_coalesced_mmio_ring + ) , "::" , stringify ! ( coalesced_mmio ) )); +} +impl Clone for kvm_coalesced_mmio_ring { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_translation { + pub linear_address: __u64, + pub physical_address: __u64, + pub valid: __u8, + pub writeable: __u8, + pub usermode: __u8, + pub pad: [__u8; 5usize], +} +#[test] +fn bindgen_test_layout_kvm_translation() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_translation ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_translation ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . linear_address as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( linear_address ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . physical_address as + * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( physical_address ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . valid as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( valid ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . writeable as * + const _ as usize } , 17usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( writeable ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . usermode as * const + _ as usize } , 18usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( usermode ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_translation ) ) . pad as * const _ as + usize } , 19usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_translation ) , + "::" , stringify ! ( pad ) )); +} +impl Clone for kvm_translation { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_mem_op { + pub gaddr: __u64, + pub flags: __u64, + pub size: __u32, + pub op: __u32, + pub buf: __u64, + pub ar: __u8, + pub reserved: [__u8; 31usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_mem_op() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_s390_mem_op ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_s390_mem_op ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . gaddr as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( gaddr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . flags as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . size as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . op as * const _ as + usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( op ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . buf as * const _ as + usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( buf ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . ar as * const _ as + usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( ar ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mem_op ) ) . reserved as * const + _ as usize } , 33usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mem_op ) , + "::" , stringify ! ( reserved ) )); +} +impl Clone for kvm_s390_mem_op { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_interrupt { + pub irq: __u32, +} +#[test] +fn bindgen_test_layout_kvm_interrupt() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( + "Size of: " , stringify ! ( kvm_interrupt ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_interrupt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_interrupt ) ) . irq as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_interrupt ) , "::" + , stringify ! ( irq ) )); +} +impl Clone for kvm_interrupt { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_dirty_log { + pub slot: __u32, + pub padding1: __u32, + pub __bindgen_anon_1: kvm_dirty_log__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_dirty_log__bindgen_ty_1 { + pub dirty_bitmap: *mut ::std::os::raw::c_void, + pub padding2: __u64, +} +#[test] +fn bindgen_test_layout_kvm_dirty_log__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( + "Size of: " , stringify ! ( kvm_dirty_log__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , 8usize + , concat ! ( + "Alignment of " , stringify ! ( kvm_dirty_log__bindgen_ty_1 ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_log__bindgen_ty_1 ) ) . + dirty_bitmap as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_dirty_log__bindgen_ty_1 ) , "::" , stringify ! ( + dirty_bitmap ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_log__bindgen_ty_1 ) ) . + padding2 as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_dirty_log__bindgen_ty_1 ) , "::" , stringify ! ( padding2 + ) )); +} +impl Clone for kvm_dirty_log__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_dirty_log() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_dirty_log ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_dirty_log ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_log ) ) . slot as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dirty_log ) , "::" + , stringify ! ( slot ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_log ) ) . padding1 as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dirty_log ) , "::" + , stringify ! ( padding1 ) )); +} +impl Clone for kvm_dirty_log { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_signal_mask { + pub len: __u32, + pub sigset: __IncompleteArrayField<__u8>, +} +#[test] +fn bindgen_test_layout_kvm_signal_mask() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( + "Size of: " , stringify ! ( kvm_signal_mask ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_signal_mask ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_signal_mask ) ) . len as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_signal_mask ) , + "::" , stringify ! ( len ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_signal_mask ) ) . sigset as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_signal_mask ) , + "::" , stringify ! ( sigset ) )); +} +impl Clone for kvm_signal_mask { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_tpr_access_ctl { + pub enabled: __u32, + pub flags: __u32, + pub reserved: [__u32; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_tpr_access_ctl() { + assert_eq!(::std::mem::size_of::() , 40usize , concat + ! ( "Size of: " , stringify ! ( kvm_tpr_access_ctl ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat + ! ( "Alignment of " , stringify ! ( kvm_tpr_access_ctl ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_tpr_access_ctl ) ) . enabled as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_tpr_access_ctl ) , + "::" , stringify ! ( enabled ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_tpr_access_ctl ) ) . flags as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_tpr_access_ctl ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_tpr_access_ctl ) ) . reserved as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_tpr_access_ctl ) , + "::" , stringify ! ( reserved ) )); +} +impl Clone for kvm_tpr_access_ctl { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_vapic_addr { + pub vapic_addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_vapic_addr() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_vapic_addr ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_vapic_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_vapic_addr ) ) . vapic_addr as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_vapic_addr ) , "::" + , stringify ! ( vapic_addr ) )); +} +impl Clone for kvm_vapic_addr { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_mp_state { + pub mp_state: __u32, +} +#[test] +fn bindgen_test_layout_kvm_mp_state() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! ( + "Size of: " , stringify ! ( kvm_mp_state ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_mp_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_mp_state ) ) . mp_state as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_mp_state ) , "::" , + stringify ! ( mp_state ) )); +} +impl Clone for kvm_mp_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_psw { + pub mask: __u64, + pub addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_s390_psw() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_s390_psw ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_s390_psw ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_psw ) ) . mask as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_psw ) , "::" , + stringify ! ( mask ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_psw ) ) . addr as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_psw ) , "::" , + stringify ! ( addr ) )); +} +impl Clone for kvm_s390_psw { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_interrupt { + pub type_: __u32, + pub parm: __u32, + pub parm64: __u64, +} +#[test] +fn bindgen_test_layout_kvm_s390_interrupt() { + assert_eq!(::std::mem::size_of::() , 16usize , concat + ! ( "Size of: " , stringify ! ( kvm_s390_interrupt ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_interrupt ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_interrupt ) ) . type_ as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_interrupt ) , + "::" , stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_interrupt ) ) . parm as * const + _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_interrupt ) , + "::" , stringify ! ( parm ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_interrupt ) ) . parm64 as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_interrupt ) , + "::" , stringify ! ( parm64 ) )); +} +impl Clone for kvm_s390_interrupt { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_io_info { + pub subchannel_id: __u16, + pub subchannel_nr: __u16, + pub io_int_parm: __u32, + pub io_int_word: __u32, +} +#[test] +fn bindgen_test_layout_kvm_s390_io_info() { + assert_eq!(::std::mem::size_of::() , 12usize , concat ! + ( "Size of: " , stringify ! ( kvm_s390_io_info ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_s390_io_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_io_info ) ) . subchannel_id as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_io_info ) , + "::" , stringify ! ( subchannel_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_io_info ) ) . subchannel_nr as * + const _ as usize } , 2usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_io_info ) , + "::" , stringify ! ( subchannel_nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_io_info ) ) . io_int_parm as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_io_info ) , + "::" , stringify ! ( io_int_parm ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_io_info ) ) . io_int_word as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_io_info ) , + "::" , stringify ! ( io_int_word ) )); +} +impl Clone for kvm_s390_io_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_ext_info { + pub ext_params: __u32, + pub pad: __u32, + pub ext_params2: __u64, +} +#[test] +fn bindgen_test_layout_kvm_s390_ext_info() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! + ( "Size of: " , stringify ! ( kvm_s390_ext_info ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_ext_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ext_info ) ) . ext_params as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ext_info ) , + "::" , stringify ! ( ext_params ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ext_info ) ) . pad as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ext_info ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ext_info ) ) . ext_params2 as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ext_info ) , + "::" , stringify ! ( ext_params2 ) )); +} +impl Clone for kvm_s390_ext_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_pgm_info { + pub trans_exc_code: __u64, + pub mon_code: __u64, + pub per_address: __u64, + pub data_exc_code: __u32, + pub code: __u16, + pub mon_class_nr: __u16, + pub per_code: __u8, + pub per_atmid: __u8, + pub exc_access_id: __u8, + pub per_access_id: __u8, + pub op_access_id: __u8, + pub flags: __u8, + pub pad: [__u8; 2usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_pgm_info() { + assert_eq!(::std::mem::size_of::() , 40usize , concat ! + ( "Size of: " , stringify ! ( kvm_s390_pgm_info ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_pgm_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . trans_exc_code as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( trans_exc_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . mon_code as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( mon_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . per_address as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( per_address ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . data_exc_code as + * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( data_exc_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . code as * const _ + as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . mon_class_nr as * + const _ as usize } , 30usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( mon_class_nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . per_code as * + const _ as usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( per_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . per_atmid as * + const _ as usize } , 33usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( per_atmid ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . exc_access_id as + * const _ as usize } , 34usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( exc_access_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . per_access_id as + * const _ as usize } , 35usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( per_access_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . op_access_id as * + const _ as usize } , 36usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( op_access_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . flags as * const + _ as usize } , 37usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_pgm_info ) ) . pad as * const _ + as usize } , 38usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_pgm_info ) , + "::" , stringify ! ( pad ) )); +} +impl Clone for kvm_s390_pgm_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_prefix_info { + pub address: __u32, +} +#[test] +fn bindgen_test_layout_kvm_s390_prefix_info() { + assert_eq!(::std::mem::size_of::() , 4usize , concat + ! ( "Size of: " , stringify ! ( kvm_s390_prefix_info ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_s390_prefix_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_prefix_info ) ) . address as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_prefix_info ) + , "::" , stringify ! ( address ) )); +} +impl Clone for kvm_s390_prefix_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_extcall_info { + pub code: __u16, +} +#[test] +fn bindgen_test_layout_kvm_s390_extcall_info() { + assert_eq!(::std::mem::size_of::() , 2usize , + concat ! ( "Size of: " , stringify ! ( kvm_s390_extcall_info ) + )); + assert_eq! (::std::mem::align_of::() , 2usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_s390_extcall_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_extcall_info ) ) . code as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_extcall_info ) + , "::" , stringify ! ( code ) )); +} +impl Clone for kvm_s390_extcall_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_emerg_info { + pub code: __u16, +} +#[test] +fn bindgen_test_layout_kvm_s390_emerg_info() { + assert_eq!(::std::mem::size_of::() , 2usize , concat + ! ( "Size of: " , stringify ! ( kvm_s390_emerg_info ) )); + assert_eq! (::std::mem::align_of::() , 2usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_s390_emerg_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_emerg_info ) ) . code as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_emerg_info ) , + "::" , stringify ! ( code ) )); +} +impl Clone for kvm_s390_emerg_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_stop_info { + pub flags: __u32, +} +#[test] +fn bindgen_test_layout_kvm_s390_stop_info() { + assert_eq!(::std::mem::size_of::() , 4usize , concat ! + ( "Size of: " , stringify ! ( kvm_s390_stop_info ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_stop_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_stop_info ) ) . flags as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_stop_info ) , + "::" , stringify ! ( flags ) )); +} +impl Clone for kvm_s390_stop_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_mchk_info { + pub cr14: __u64, + pub mcic: __u64, + pub failing_storage_address: __u64, + pub ext_damage_code: __u32, + pub pad: __u32, + pub fixed_logout: [__u8; 16usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_mchk_info() { + assert_eq!(::std::mem::size_of::() , 48usize , concat + ! ( "Size of: " , stringify ! ( kvm_s390_mchk_info ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_mchk_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . cr14 as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( cr14 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . mcic as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( mcic ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . + failing_storage_address as * const _ as usize } , 16usize , + concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( failing_storage_address ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . ext_damage_code + as * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( ext_damage_code ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . pad as * const _ + as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_mchk_info ) ) . fixed_logout as + * const _ as usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_mchk_info ) , + "::" , stringify ! ( fixed_logout ) )); +} +impl Clone for kvm_s390_mchk_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +pub struct kvm_s390_irq { + pub type_: __u64, + pub u: kvm_s390_irq__bindgen_ty_1, +} +#[repr(C)] +pub union kvm_s390_irq__bindgen_ty_1 { + pub io: kvm_s390_io_info, + pub ext: kvm_s390_ext_info, + pub pgm: kvm_s390_pgm_info, + pub emerg: kvm_s390_emerg_info, + pub extcall: kvm_s390_extcall_info, + pub prefix: kvm_s390_prefix_info, + pub stop: kvm_s390_stop_info, + pub mchk: kvm_s390_mchk_info, + pub reserved: [::std::os::raw::c_char; 64usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_irq__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , 64usize , + concat ! ( + "Size of: " , stringify ! ( kvm_s390_irq__bindgen_ty_1 ) )); + assert_eq! (::std::mem::align_of::() , 8usize + , concat ! ( + "Alignment of " , stringify ! ( kvm_s390_irq__bindgen_ty_1 ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . io as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( io ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . ext as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( ext ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . pgm as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( pgm ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . emerg as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( emerg ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . extcall + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( extcall ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . prefix + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( prefix ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . stop as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( stop ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . mchk as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( mchk ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq__bindgen_ty_1 ) ) . reserved + as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_s390_irq__bindgen_ty_1 ) , "::" , stringify ! ( reserved ) + )); +} +#[test] +fn bindgen_test_layout_kvm_s390_irq() { + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( + "Size of: " , stringify ! ( kvm_s390_irq ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_s390_irq ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq ) ) . type_ as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq ) , "::" , + stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq ) ) . u as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq ) , "::" , + stringify ! ( u ) )); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_irq_state { + pub buf: __u64, + pub flags: __u32, + pub len: __u32, + pub reserved: [__u32; 4usize], +} +#[test] +fn bindgen_test_layout_kvm_s390_irq_state() { + assert_eq!(::std::mem::size_of::() , 32usize , concat + ! ( "Size of: " , stringify ! ( kvm_s390_irq_state ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_s390_irq_state ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq_state ) ) . buf as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq_state ) , + "::" , stringify ! ( buf ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq_state ) ) . flags as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq_state ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq_state ) ) . len as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq_state ) , + "::" , stringify ! ( len ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_irq_state ) ) . reserved as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_irq_state ) , + "::" , stringify ! ( reserved ) )); +} +impl Clone for kvm_s390_irq_state { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_guest_debug { + pub control: __u32, + pub pad: __u32, + pub arch: kvm_guest_debug_arch, +} +#[test] +fn bindgen_test_layout_kvm_guest_debug() { + assert_eq!(::std::mem::size_of::() , 72usize , concat ! ( + "Size of: " , stringify ! ( kvm_guest_debug ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_guest_debug ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_guest_debug ) ) . control as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_guest_debug ) , + "::" , stringify ! ( control ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_guest_debug ) ) . pad as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_guest_debug ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_guest_debug ) ) . arch as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_guest_debug ) , + "::" , stringify ! ( arch ) )); +} +impl Clone for kvm_guest_debug { + fn clone(&self) -> Self { *self } +} +pub const kvm_ioeventfd_flag_nr_datamatch: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_datamatch; +pub const kvm_ioeventfd_flag_nr_pio: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_pio; +pub const kvm_ioeventfd_flag_nr_deassign: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_deassign; +pub const kvm_ioeventfd_flag_nr_virtio_ccw_notify: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_virtio_ccw_notify; +pub const kvm_ioeventfd_flag_nr_fast_mmio: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_fast_mmio; +pub const kvm_ioeventfd_flag_nr_max: _bindgen_ty_1 = + _bindgen_ty_1::kvm_ioeventfd_flag_nr_max; +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum _bindgen_ty_1 { + kvm_ioeventfd_flag_nr_datamatch = 0, + kvm_ioeventfd_flag_nr_pio = 1, + kvm_ioeventfd_flag_nr_deassign = 2, + kvm_ioeventfd_flag_nr_virtio_ccw_notify = 3, + kvm_ioeventfd_flag_nr_fast_mmio = 4, + kvm_ioeventfd_flag_nr_max = 5, +} +#[repr(C)] +pub struct kvm_ioeventfd { + pub datamatch: __u64, + pub addr: __u64, + pub len: __u32, + pub fd: __s32, + pub flags: __u32, + pub pad: [__u8; 36usize], +} +#[test] +fn bindgen_test_layout_kvm_ioeventfd() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_ioeventfd ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_ioeventfd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . datamatch as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( datamatch ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . addr as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . len as * const _ as + usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( len ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . fd as * const _ as + usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( fd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . flags as * const _ as + usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ioeventfd ) ) . pad as * const _ as + usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ioeventfd ) , "::" + , stringify ! ( pad ) )); +} +#[repr(C)] +pub struct kvm_enable_cap { + pub cap: __u32, + pub flags: __u32, + pub args: [__u64; 4usize], + pub pad: [__u8; 64usize], +} +#[test] +fn bindgen_test_layout_kvm_enable_cap() { + assert_eq!(::std::mem::size_of::() , 104usize , concat ! ( + "Size of: " , stringify ! ( kvm_enable_cap ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_enable_cap ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_enable_cap ) ) . cap as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_enable_cap ) , "::" + , stringify ! ( cap ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_enable_cap ) ) . flags as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_enable_cap ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_enable_cap ) ) . args as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_enable_cap ) , "::" + , stringify ! ( args ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_enable_cap ) ) . pad as * const _ as + usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_enable_cap ) , "::" + , stringify ! ( pad ) )); +} +#[repr(C)] +pub struct kvm_ppc_pvinfo { + pub flags: __u32, + pub hcall: [__u32; 4usize], + pub pad: [__u8; 108usize], +} +#[test] +fn bindgen_test_layout_kvm_ppc_pvinfo() { + assert_eq!(::std::mem::size_of::() , 128usize , concat ! ( + "Size of: " , stringify ! ( kvm_ppc_pvinfo ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_ppc_pvinfo ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_pvinfo ) ) . flags as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_pvinfo ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_pvinfo ) ) . hcall as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_pvinfo ) , "::" + , stringify ! ( hcall ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_pvinfo ) ) . pad as * const _ as + usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_pvinfo ) , "::" + , stringify ! ( pad ) )); +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_ppc_one_page_size { + pub page_shift: __u32, + pub pte_enc: __u32, +} +#[test] +fn bindgen_test_layout_kvm_ppc_one_page_size() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( "Size of: " , stringify ! ( kvm_ppc_one_page_size ) + )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_ppc_one_page_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_one_page_size ) ) . page_shift as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_one_page_size ) + , "::" , stringify ! ( page_shift ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_one_page_size ) ) . pte_enc as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_one_page_size ) + , "::" , stringify ! ( pte_enc ) )); +} +impl Clone for kvm_ppc_one_page_size { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_ppc_one_seg_page_size { + pub page_shift: __u32, + pub slb_enc: __u32, + pub enc: [kvm_ppc_one_page_size; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_ppc_one_seg_page_size() { + assert_eq!(::std::mem::size_of::() , 72usize , + concat ! ( + "Size of: " , stringify ! ( kvm_ppc_one_seg_page_size ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_ppc_one_seg_page_size ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_one_seg_page_size ) ) . + page_shift as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ppc_one_seg_page_size ) , "::" , stringify ! ( page_shift + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_one_seg_page_size ) ) . slb_enc + as * const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ppc_one_seg_page_size ) , "::" , stringify ! ( slb_enc ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_one_seg_page_size ) ) . enc as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_ppc_one_seg_page_size ) , "::" , stringify ! ( enc ) )); +} +impl Clone for kvm_ppc_one_seg_page_size { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_ppc_smmu_info { + pub flags: __u64, + pub slb_size: __u32, + pub pad: __u32, + pub sps: [kvm_ppc_one_seg_page_size; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_ppc_smmu_info() { + assert_eq!(::std::mem::size_of::() , 592usize , concat + ! ( "Size of: " , stringify ! ( kvm_ppc_smmu_info ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_ppc_smmu_info ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_smmu_info ) ) . flags as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_smmu_info ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_smmu_info ) ) . slb_size as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_smmu_info ) , + "::" , stringify ! ( slb_size ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_smmu_info ) ) . pad as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_smmu_info ) , + "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_ppc_smmu_info ) ) . sps as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_ppc_smmu_info ) , + "::" , stringify ! ( sps ) )); +} +impl Clone for kvm_ppc_smmu_info { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_irq_routing_irqchip { + pub irqchip: __u32, + pub pin: __u32, +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_irqchip() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( + "Size of: " , stringify ! ( kvm_irq_routing_irqchip ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_irq_routing_irqchip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_irqchip ) ) . irqchip as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_irqchip + ) , "::" , stringify ! ( irqchip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_irqchip ) ) . pin as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_irqchip + ) , "::" , stringify ! ( pin ) )); +} +impl Clone for kvm_irq_routing_irqchip { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_irq_routing_msi { + pub address_lo: __u32, + pub address_hi: __u32, + pub data: __u32, + pub pad: __u32, +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_msi() { + assert_eq!(::std::mem::size_of::() , 16usize , concat + ! ( "Size of: " , stringify ! ( kvm_irq_routing_msi ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_irq_routing_msi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_msi ) ) . address_lo as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_msi ) , + "::" , stringify ! ( address_lo ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_msi ) ) . address_hi as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_msi ) , + "::" , stringify ! ( address_hi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_msi ) ) . data as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_msi ) , + "::" , stringify ! ( data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_msi ) ) . pad as * const + _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_msi ) , + "::" , stringify ! ( pad ) )); +} +impl Clone for kvm_irq_routing_msi { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_irq_routing_s390_adapter { + pub ind_addr: __u64, + pub summary_addr: __u64, + pub ind_offset: __u64, + pub summary_offset: __u32, + pub adapter_id: __u32, +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_s390_adapter() { + assert_eq!(::std::mem::size_of::() , 32usize + , concat ! ( + "Size of: " , stringify ! ( kvm_irq_routing_s390_adapter ) )); + assert_eq! (::std::mem::align_of::() , + 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_irq_routing_s390_adapter ) + )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_s390_adapter ) ) . + ind_addr as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_s390_adapter ) , "::" , stringify ! ( ind_addr + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_s390_adapter ) ) . + summary_addr as * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_s390_adapter ) , "::" , stringify ! ( + summary_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_s390_adapter ) ) . + ind_offset as * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_s390_adapter ) , "::" , stringify ! ( + ind_offset ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_s390_adapter ) ) . + summary_offset as * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_s390_adapter ) , "::" , stringify ! ( + summary_offset ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_s390_adapter ) ) . + adapter_id as * const _ as usize } , 28usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_s390_adapter ) , "::" , stringify ! ( + adapter_id ) )); +} +impl Clone for kvm_irq_routing_s390_adapter { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_irq_routing_hv_sint { + pub vcpu: __u32, + pub sint: __u32, +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_hv_sint() { + assert_eq!(::std::mem::size_of::() , 8usize , + concat ! ( + "Size of: " , stringify ! ( kvm_irq_routing_hv_sint ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_irq_routing_hv_sint ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_hv_sint ) ) . vcpu as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_hv_sint + ) , "::" , stringify ! ( vcpu ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_hv_sint ) ) . sint as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_hv_sint + ) , "::" , stringify ! ( sint ) )); +} +impl Clone for kvm_irq_routing_hv_sint { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_irq_routing_entry { + pub gsi: __u32, + pub type_: __u32, + pub flags: __u32, + pub pad: __u32, + pub u: kvm_irq_routing_entry__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_irq_routing_entry__bindgen_ty_1 { + pub irqchip: kvm_irq_routing_irqchip, + pub msi: kvm_irq_routing_msi, + pub adapter: kvm_irq_routing_s390_adapter, + pub hv_sint: kvm_irq_routing_hv_sint, + pub pad: [__u32; 8usize], +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_entry__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 32usize , concat ! ( + "Size of: " , stringify ! ( kvm_irq_routing_entry__bindgen_ty_1 + ) )); + assert_eq! (::std::mem::align_of::() + , 8usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry__bindgen_ty_1 ) ) . + irqchip as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) , "::" , stringify ! ( + irqchip ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry__bindgen_ty_1 ) ) . + msi as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) , "::" , stringify ! ( + msi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry__bindgen_ty_1 ) ) . + adapter as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) , "::" , stringify ! ( + adapter ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry__bindgen_ty_1 ) ) . + hv_sint as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) , "::" , stringify ! ( + hv_sint ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry__bindgen_ty_1 ) ) . + pad as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_irq_routing_entry__bindgen_ty_1 ) , "::" , stringify ! ( + pad ) )); +} +impl Clone for kvm_irq_routing_entry__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_irq_routing_entry() { + assert_eq!(::std::mem::size_of::() , 48usize , + concat ! ( "Size of: " , stringify ! ( kvm_irq_routing_entry ) + )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_irq_routing_entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry ) ) . gsi as * + const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_entry ) + , "::" , stringify ! ( gsi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry ) ) . type_ as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_entry ) + , "::" , stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry ) ) . flags as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_entry ) + , "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry ) ) . pad as * + const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_entry ) + , "::" , stringify ! ( pad ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing_entry ) ) . u as * const + _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing_entry ) + , "::" , stringify ! ( u ) )); +} +impl Clone for kvm_irq_routing_entry { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_irq_routing { + pub nr: __u32, + pub flags: __u32, + pub entries: __IncompleteArrayField, +} +#[test] +fn bindgen_test_layout_kvm_irq_routing() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_irq_routing ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_irq_routing ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing ) ) . nr as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing ) , + "::" , stringify ! ( nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing ) ) . flags as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irq_routing ) ) . entries as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irq_routing ) , + "::" , stringify ! ( entries ) )); +} +impl Clone for kvm_irq_routing { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_x86_mce { + pub status: __u64, + pub addr: __u64, + pub misc: __u64, + pub mcg_status: __u64, + pub bank: __u8, + pub pad1: [__u8; 7usize], + pub pad2: [__u64; 3usize], +} +#[test] +fn bindgen_test_layout_kvm_x86_mce() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! ( + "Size of: " , stringify ! ( kvm_x86_mce ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_x86_mce ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . status as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( status ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . addr as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . misc as * const _ as + usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( misc ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . mcg_status as * const _ + as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( mcg_status ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . bank as * const _ as + usize } , 32usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( bank ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . pad1 as * const _ as + usize } , 33usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( pad1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_x86_mce ) ) . pad2 as * const _ as + usize } , 40usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_x86_mce ) , "::" , + stringify ! ( pad2 ) )); +} +impl Clone for kvm_x86_mce { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_xen_hvm_config { + pub flags: __u32, + pub msr: __u32, + pub blob_addr_32: __u64, + pub blob_addr_64: __u64, + pub blob_size_32: __u8, + pub blob_size_64: __u8, + pub pad2: [__u8; 30usize], +} +#[test] +fn bindgen_test_layout_kvm_xen_hvm_config() { + assert_eq!(::std::mem::size_of::() , 56usize , concat + ! ( "Size of: " , stringify ! ( kvm_xen_hvm_config ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat + ! ( "Alignment of " , stringify ! ( kvm_xen_hvm_config ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . flags as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . msr as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( msr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . blob_addr_32 as + * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( blob_addr_32 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . blob_addr_64 as + * const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( blob_addr_64 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . blob_size_32 as + * const _ as usize } , 24usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( blob_size_32 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . blob_size_64 as + * const _ as usize } , 25usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( blob_size_64 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_xen_hvm_config ) ) . pad2 as * const + _ as usize } , 26usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_xen_hvm_config ) , + "::" , stringify ! ( pad2 ) )); +} +impl Clone for kvm_xen_hvm_config { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_irqfd { + pub fd: __u32, + pub gsi: __u32, + pub flags: __u32, + pub resamplefd: __u32, + pub pad: [__u8; 16usize], +} +#[test] +fn bindgen_test_layout_kvm_irqfd() { + assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( + "Size of: " , stringify ! ( kvm_irqfd ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_irqfd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqfd ) ) . fd as * const _ as usize + } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqfd ) , "::" , + stringify ! ( fd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqfd ) ) . gsi as * const _ as usize + } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqfd ) , "::" , + stringify ! ( gsi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqfd ) ) . flags as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqfd ) , "::" , + stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqfd ) ) . resamplefd as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqfd ) , "::" , + stringify ! ( resamplefd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_irqfd ) ) . pad as * const _ as usize + } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_irqfd ) , "::" , + stringify ! ( pad ) )); +} +impl Clone for kvm_irqfd { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_clock_data { + pub clock: __u64, + pub flags: __u32, + pub pad: [__u32; 9usize], +} +#[test] +fn bindgen_test_layout_kvm_clock_data() { + assert_eq!(::std::mem::size_of::() , 48usize , concat ! ( + "Size of: " , stringify ! ( kvm_clock_data ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_clock_data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_clock_data ) ) . clock as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_clock_data ) , "::" + , stringify ! ( clock ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_clock_data ) ) . flags as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_clock_data ) , "::" + , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_clock_data ) ) . pad as * const _ as + usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_clock_data ) , "::" + , stringify ! ( pad ) )); +} +impl Clone for kvm_clock_data { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_config_tlb { + pub params: __u64, + pub array: __u64, + pub mmu_type: __u32, + pub array_len: __u32, +} +#[test] +fn bindgen_test_layout_kvm_config_tlb() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_config_tlb ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_config_tlb ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_config_tlb ) ) . params as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_config_tlb ) , "::" + , stringify ! ( params ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_config_tlb ) ) . array as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_config_tlb ) , "::" + , stringify ! ( array ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_config_tlb ) ) . mmu_type as * const + _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_config_tlb ) , "::" + , stringify ! ( mmu_type ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_config_tlb ) ) . array_len as * const + _ as usize } , 20usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_config_tlb ) , "::" + , stringify ! ( array_len ) )); +} +impl Clone for kvm_config_tlb { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_dirty_tlb { + pub bitmap: __u64, + pub num_dirty: __u32, +} +#[test] +fn bindgen_test_layout_kvm_dirty_tlb() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_dirty_tlb ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_dirty_tlb ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_tlb ) ) . bitmap as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dirty_tlb ) , "::" + , stringify ! ( bitmap ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_dirty_tlb ) ) . num_dirty as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_dirty_tlb ) , "::" + , stringify ! ( num_dirty ) )); +} +impl Clone for kvm_dirty_tlb { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_reg_list { + pub n: __u64, + pub reg: __IncompleteArrayField<__u64>, +} +#[test] +fn bindgen_test_layout_kvm_reg_list() { + assert_eq!(::std::mem::size_of::() , 8usize , concat ! ( + "Size of: " , stringify ! ( kvm_reg_list ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_reg_list ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_reg_list ) ) . n as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_reg_list ) , "::" , + stringify ! ( n ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_reg_list ) ) . reg as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_reg_list ) , "::" , + stringify ! ( reg ) )); +} +impl Clone for kvm_reg_list { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_one_reg { + pub id: __u64, + pub addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_one_reg() { + assert_eq!(::std::mem::size_of::() , 16usize , concat ! ( + "Size of: " , stringify ! ( kvm_one_reg ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! ( + "Alignment of " , stringify ! ( kvm_one_reg ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_one_reg ) ) . id as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_one_reg ) , "::" , + stringify ! ( id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_one_reg ) ) . addr as * const _ as + usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_one_reg ) , "::" , + stringify ! ( addr ) )); +} +impl Clone for kvm_one_reg { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_msi { + pub address_lo: __u32, + pub address_hi: __u32, + pub data: __u32, + pub flags: __u32, + pub pad: [__u8; 16usize], +} +#[test] +fn bindgen_test_layout_kvm_msi() { + assert_eq!(::std::mem::size_of::() , 32usize , concat ! ( + "Size of: " , stringify ! ( kvm_msi ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_msi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msi ) ) . address_lo as * const _ as + usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msi ) , "::" , + stringify ! ( address_lo ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msi ) ) . address_hi as * const _ as + usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msi ) , "::" , + stringify ! ( address_hi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msi ) ) . data as * const _ as usize + } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msi ) , "::" , + stringify ! ( data ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msi ) ) . flags as * const _ as usize + } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msi ) , "::" , + stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_msi ) ) . pad as * const _ as usize } + , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_msi ) , "::" , + stringify ! ( pad ) )); +} +impl Clone for kvm_msi { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_arm_device_addr { + pub id: __u64, + pub addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_arm_device_addr() { + assert_eq!(::std::mem::size_of::() , 16usize , concat + ! ( "Size of: " , stringify ! ( kvm_arm_device_addr ) )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_arm_device_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_arm_device_addr ) ) . id as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_arm_device_addr ) , + "::" , stringify ! ( id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_arm_device_addr ) ) . addr as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_arm_device_addr ) , + "::" , stringify ! ( addr ) )); +} +impl Clone for kvm_arm_device_addr { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_create_device { + pub type_: __u32, + pub fd: __u32, + pub flags: __u32, +} +#[test] +fn bindgen_test_layout_kvm_create_device() { + assert_eq!(::std::mem::size_of::() , 12usize , concat ! + ( "Size of: " , stringify ! ( kvm_create_device ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat + ! ( "Alignment of " , stringify ! ( kvm_create_device ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_create_device ) ) . type_ as * const + _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_create_device ) , + "::" , stringify ! ( type_ ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_create_device ) ) . fd as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_create_device ) , + "::" , stringify ! ( fd ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_create_device ) ) . flags as * const + _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_create_device ) , + "::" , stringify ! ( flags ) )); +} +impl Clone for kvm_create_device { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_device_attr { + pub flags: __u32, + pub group: __u32, + pub attr: __u64, + pub addr: __u64, +} +#[test] +fn bindgen_test_layout_kvm_device_attr() { + assert_eq!(::std::mem::size_of::() , 24usize , concat ! ( + "Size of: " , stringify ! ( kvm_device_attr ) )); + assert_eq! (::std::mem::align_of::() , 8usize , concat ! + ( "Alignment of " , stringify ! ( kvm_device_attr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_device_attr ) ) . flags as * const _ + as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_device_attr ) , + "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_device_attr ) ) . group as * const _ + as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_device_attr ) , + "::" , stringify ! ( group ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_device_attr ) ) . attr as * const _ + as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_device_attr ) , + "::" , stringify ! ( attr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_device_attr ) ) . addr as * const _ + as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_device_attr ) , + "::" , stringify ! ( addr ) )); +} +impl Clone for kvm_device_attr { + fn clone(&self) -> Self { *self } +} +#[repr(u32)] +#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] +pub enum kvm_device_type { + KVM_DEV_TYPE_FSL_MPIC_20 = 1, + KVM_DEV_TYPE_FSL_MPIC_42 = 2, + KVM_DEV_TYPE_XICS = 3, + KVM_DEV_TYPE_VFIO = 4, + KVM_DEV_TYPE_ARM_VGIC_V2 = 5, + KVM_DEV_TYPE_FLIC = 6, + KVM_DEV_TYPE_ARM_VGIC_V3 = 7, + KVM_DEV_TYPE_MAX = 8, +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_s390_ucas_mapping { + pub user_addr: __u64, + pub vcpu_addr: __u64, + pub length: __u64, +} +#[test] +fn bindgen_test_layout_kvm_s390_ucas_mapping() { + assert_eq!(::std::mem::size_of::() , 24usize , + concat ! ( "Size of: " , stringify ! ( kvm_s390_ucas_mapping ) + )); + assert_eq! (::std::mem::align_of::() , 8usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_s390_ucas_mapping ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ucas_mapping ) ) . user_addr as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ucas_mapping ) + , "::" , stringify ! ( user_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ucas_mapping ) ) . vcpu_addr as + * const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ucas_mapping ) + , "::" , stringify ! ( vcpu_addr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_s390_ucas_mapping ) ) . length as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_s390_ucas_mapping ) + , "::" , stringify ! ( length ) )); +} +impl Clone for kvm_s390_ucas_mapping { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_assigned_pci_dev { + pub assigned_dev_id: __u32, + pub busnr: __u32, + pub devfn: __u32, + pub flags: __u32, + pub segnr: __u32, + pub __bindgen_anon_1: kvm_assigned_pci_dev__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_assigned_pci_dev__bindgen_ty_1 { + pub reserved: [__u32; 11usize], +} +#[test] +fn bindgen_test_layout_kvm_assigned_pci_dev__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 44usize , concat ! ( + "Size of: " , stringify ! ( kvm_assigned_pci_dev__bindgen_ty_1 + ) )); + assert_eq! (::std::mem::align_of::() , + 4usize , concat ! ( + "Alignment of " , stringify ! ( + kvm_assigned_pci_dev__bindgen_ty_1 ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev__bindgen_ty_1 ) ) . + reserved as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_assigned_pci_dev__bindgen_ty_1 ) , "::" , stringify ! ( + reserved ) )); +} +impl Clone for kvm_assigned_pci_dev__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_assigned_pci_dev() { + assert_eq!(::std::mem::size_of::() , 64usize , + concat ! ( "Size of: " , stringify ! ( kvm_assigned_pci_dev ) + )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_assigned_pci_dev ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev ) ) . + assigned_dev_id as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_pci_dev ) + , "::" , stringify ! ( assigned_dev_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev ) ) . busnr as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_pci_dev ) + , "::" , stringify ! ( busnr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev ) ) . devfn as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_pci_dev ) + , "::" , stringify ! ( devfn ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev ) ) . flags as * + const _ as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_pci_dev ) + , "::" , stringify ! ( flags ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_pci_dev ) ) . segnr as * + const _ as usize } , 16usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_pci_dev ) + , "::" , stringify ! ( segnr ) )); +} +impl Clone for kvm_assigned_pci_dev { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Copy)] +pub struct kvm_assigned_irq { + pub assigned_dev_id: __u32, + pub host_irq: __u32, + pub guest_irq: __u32, + pub flags: __u32, + pub __bindgen_anon_1: kvm_assigned_irq__bindgen_ty_1, +} +#[repr(C)] +#[derive(Copy)] +pub union kvm_assigned_irq__bindgen_ty_1 { + pub reserved: [__u32; 12usize], +} +#[test] +fn bindgen_test_layout_kvm_assigned_irq__bindgen_ty_1() { + assert_eq!(::std::mem::size_of::() , + 48usize , concat ! ( + "Size of: " , stringify ! ( kvm_assigned_irq__bindgen_ty_1 ) + )); + assert_eq! (::std::mem::align_of::() , + 4usize , concat ! ( + "Alignment of " , stringify ! ( kvm_assigned_irq__bindgen_ty_1 + ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_irq__bindgen_ty_1 ) ) . + reserved as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( + kvm_assigned_irq__bindgen_ty_1 ) , "::" , stringify ! ( + reserved ) )); +} +impl Clone for kvm_assigned_irq__bindgen_ty_1 { + fn clone(&self) -> Self { *self } +} +#[test] +fn bindgen_test_layout_kvm_assigned_irq() { + assert_eq!(::std::mem::size_of::() , 64usize , concat ! + ( "Size of: " , stringify ! ( kvm_assigned_irq ) )); + assert_eq! (::std::mem::align_of::() , 4usize , concat ! + ( "Alignment of " , stringify ! ( kvm_assigned_irq ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_irq ) ) . assigned_dev_id as + * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_irq ) , + "::" , stringify ! ( assigned_dev_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_irq ) ) . host_irq as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_irq ) , + "::" , stringify ! ( host_irq ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_irq ) ) . guest_irq as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_irq ) , + "::" , stringify ! ( guest_irq ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_irq ) ) . flags as * const _ + as usize } , 12usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_irq ) , + "::" , stringify ! ( flags ) )); +} +impl Clone for kvm_assigned_irq { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_assigned_msix_nr { + pub assigned_dev_id: __u32, + pub entry_nr: __u16, + pub padding: __u16, +} +#[test] +fn bindgen_test_layout_kvm_assigned_msix_nr() { + assert_eq!(::std::mem::size_of::() , 8usize , concat + ! ( "Size of: " , stringify ! ( kvm_assigned_msix_nr ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_assigned_msix_nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_nr ) ) . + assigned_dev_id as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_nr ) + , "::" , stringify ! ( assigned_dev_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_nr ) ) . entry_nr as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_nr ) + , "::" , stringify ! ( entry_nr ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_nr ) ) . padding as * + const _ as usize } , 6usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_nr ) + , "::" , stringify ! ( padding ) )); +} +impl Clone for kvm_assigned_msix_nr { + fn clone(&self) -> Self { *self } +} +#[repr(C)] +#[derive(Debug, Copy)] +pub struct kvm_assigned_msix_entry { + pub assigned_dev_id: __u32, + pub gsi: __u32, + pub entry: __u16, + pub padding: [__u16; 3usize], +} +#[test] +fn bindgen_test_layout_kvm_assigned_msix_entry() { + assert_eq!(::std::mem::size_of::() , 16usize , + concat ! ( + "Size of: " , stringify ! ( kvm_assigned_msix_entry ) )); + assert_eq! (::std::mem::align_of::() , 4usize , + concat ! ( + "Alignment of " , stringify ! ( kvm_assigned_msix_entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_entry ) ) . + assigned_dev_id as * const _ as usize } , 0usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_entry + ) , "::" , stringify ! ( assigned_dev_id ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_entry ) ) . gsi as * + const _ as usize } , 4usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_entry + ) , "::" , stringify ! ( gsi ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_entry ) ) . entry as * + const _ as usize } , 8usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_entry + ) , "::" , stringify ! ( entry ) )); + assert_eq! (unsafe { + & ( * ( 0 as * const kvm_assigned_msix_entry ) ) . padding as + * const _ as usize } , 10usize , concat ! ( + "Alignment of field: " , stringify ! ( kvm_assigned_msix_entry + ) , "::" , stringify ! ( padding ) )); +} +impl Clone for kvm_assigned_msix_entry { + fn clone(&self) -> Self { *self } +} + + diff --git a/tools/hermit_proxy/src/uhyve/mod.rs b/tools/hermit_proxy/src/uhyve/mod.rs new file mode 100644 index 000000000..e945f8358 --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/mod.rs @@ -0,0 +1,12 @@ +//gdt.rs kvm_header.rs kvm.rs mod.rs vcpu.rs vm.rs +mod gdt; +mod kvm_header; +pub mod uhyve; +pub mod vcpu; +pub mod vm; +pub mod proto; + +// reexport Uhyve to show up in the root namespace of our module +pub use self::uhyve::*; +// reexport the Error enum and Result type +pub use error::*; diff --git a/tools/hermit_proxy/src/uhyve/proto.rs b/tools/hermit_proxy/src/uhyve/proto.rs new file mode 100644 index 000000000..0a7a29541 --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/proto.rs @@ -0,0 +1,111 @@ +use libc::{write, read, lseek, exit, open, close, c_int, c_void}; +use uhyve::kvm_header::{kvm_run, KVM_EXIT_IO, KVM_EXIT_HLT, KVM_EXIT_MMIO,KVM_EXIT_FAIL_ENTRY, KVM_EXIT_INTERNAL_ERROR, KVM_EXIT_SHUTDOWN }; + +const PORT_WRITE: u16 = 0x499; +const PORT_OPEN: u16 = 0x500; +const PORT_CLOSE: u16 = 0x501; +const PORT_READ: u16 = 0x502; +const PORT_EXIT: u16 = 0x503; +const PORT_LSEEK: u16 = 0x504; + +pub struct Write { + fd: c_int, + buf: *const u8, + length: usize +} + +pub struct Open { + name: *const u8, + flags: c_int, + mode: c_int, + ret: c_int +} + +pub struct Close { + fd: c_int, + ret: c_int +} + +pub struct Read { + fd: c_int, + buf: *mut u8, + len: usize, + ret: isize +} + +pub struct LSeek { + fd: c_int, + offset: usize, + whence: c_int +} + +pub enum Syscall { + Write(*mut Write), + Open(*mut Open), + Close(*mut Close), + Read(*mut Read), + LSeek(*mut LSeek), + Exit(*mut isize), + Other(*const kvm_run) +} + +impl Syscall { + pub fn from_mem(mem: &[u8], guest_mem: &[u8]) -> Syscall { + unsafe { + let ref run = *(mem.as_ptr() as *const kvm_run); + + if run.exit_reason != KVM_EXIT_IO { + return Syscall::Other(mem.as_ptr() as *const kvm_run); + } + + let offset = mem.as_ptr().offset(run.__bindgen_anon_1.io.data_offset as isize) as isize; + + match run.__bindgen_anon_1.io.port { + PORT_WRITE => { Syscall::Write(guest_mem.as_ptr().offset(offset) as *mut Write) }, + PORT_READ => { Syscall::Read (guest_mem.as_ptr().offset(offset) as *mut Read) }, + PORT_CLOSE => { Syscall::Close(guest_mem.as_ptr().offset(offset) as *mut Close) }, + PORT_OPEN => { Syscall::Open (guest_mem.as_ptr().offset(offset) as *mut Open ) }, + PORT_LSEEK => { Syscall::LSeek(guest_mem.as_ptr().offset(offset) as *mut LSeek) }, + PORT_EXIT => { Syscall::Exit( guest_mem.as_ptr().offset(offset) as *mut isize) }, + _ => { panic!("KVM: unhandled KVM_EXIT_IO at port 0x{}, direction {}", run.__bindgen_anon_1.io.port, run.__bindgen_anon_1.io.direction); } + } + } + + } + + pub unsafe fn run(&self, guest_mem: *mut u8) { + match *self { + Syscall::Write(obj) => { + //let Write { fd, buf, length } = *write; + (*obj).length = write((*obj).fd, guest_mem.offset((*obj).buf as isize) as *const c_void, (*obj).length) as usize; + }, + Syscall::Read(obj) => { + (*obj).ret = read((*obj).fd, guest_mem.offset((*obj).buf as isize) as *mut c_void, (*obj).len) as isize; + }, + Syscall::Exit(obj) => { + exit(*((guest_mem as *mut i32).offset((*obj) as isize))); + }, + Syscall::Open(obj) => { + (*obj).ret = open((guest_mem as *const i8).offset((*obj).name as isize), (*obj).flags, (*obj).mode); + }, + Syscall::Close(obj) => { + if (*obj).ret == 2 { + (*obj).ret = close((*obj).fd); + } + }, + Syscall::LSeek(obj) => { + (*obj).offset = lseek((*obj).fd, (*obj).offset as i64, (*obj).whence) as usize; + }, + Syscall::Other(id) => { match (*id).exit_reason { + KVM_EXIT_HLT => panic!("Guest has halted the CPU, this is considered as a normal exit."), + KVM_EXIT_MMIO =>panic!("KVM: unhandled KVM_EXIT_MMIO at 0x{}", (*id).__bindgen_anon_1.mmio.phys_addr ), + KVM_EXIT_FAIL_ENTRY => panic!("KVM: entry failure: hw_entry_failure_reason=0x{}", (*id).__bindgen_anon_1.fail_entry.hardware_entry_failure_reason), + KVM_EXIT_INTERNAL_ERROR => panic!("KVM: internal error exit: suberror = 0x{}", (*id).__bindgen_anon_1.internal.suberror), + KVM_EXIT_SHUTDOWN => panic!("KVM: receive shutdown command"), + _ => { + panic!("KVM: unhandled exit: exit_reason = 0x{}", (*id).exit_reason); + } + }} + } + } +} diff --git a/tools/hermit_proxy/src/uhyve/uhyve.rs b/tools/hermit_proxy/src/uhyve/uhyve.rs new file mode 100644 index 000000000..c9abdc39a --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/uhyve.rs @@ -0,0 +1,98 @@ +//! This file contains the entry point to the Unikernel Hypervisor. The uhyve utilizes KVM to +//! create a Virtual Machine and load the kernel. + +use std::ptr; +use std::fs::{File,OpenOptions}; +use std::os::unix::fs::OpenOptionsExt; +use std::os::unix::io::AsRawFd; +use libc; + +use uhyve::{Error, Result}; +use uhyve::vm::VirtualMachine; + +/// The normal way of defining a IOCTL interface is provided by C macros. In Rust we have our own +/// flawed macro system. The module below wraps a bunch of functions which are generated by the +/// ioctl! macro and need to be wrapped further to provide a safe interface. +pub mod ioctl { + use std::mem; + use uhyve::kvm_header::{KVMIO, kvm_msr_list, kvm_cpuid2, kvm_memory_region, kvm_dirty_log, kvm_memory_alias, kvm_userspace_memory_region, kvm_regs,kvm_sregs}; + + ioctl!(get_version with io!(KVMIO, 0x00)); + ioctl!(create_vm with io!(KVMIO, 0x01)); + ioctl!(get_msr_index_list with iorw!(KVMIO, 0x02, mem::size_of::())); + ioctl!(check_extension with io!(KVMIO, 0x03)); + ioctl!(get_vcpu_mmap_size with io!(KVMIO, 0x04)); + ioctl!(get_supported_cpuid with iorw!(KVMIO, 0x05, mem::size_of::())); + ioctl!(get_emulated_cpuid with iorw!(KVMIO, 0x09, mem::size_of::())); + ioctl!(set_cpuid2 with iow!(KVMIO, 0x90, mem::size_of::())); + + + ioctl!(set_memory_region with iorw!(KVMIO, 0x40,mem::size_of::())); + ioctl!(create_vcpu with io!(KVMIO, 0x41)); + ioctl!(get_dirty_log with iow!(KVMIO, 0x42, mem::size_of::())); + ioctl!(set_memory_alias with iow!(KVMIO, 0x43, mem::size_of::())); + ioctl!(set_nr_mmu_pages with io!(KVMIO, 0x44)); + ioctl!(get_nr_mmu_pages with io!(KVMIO, 0x45)); + ioctl!(set_user_memory_region with iow!(KVMIO, 0x46, mem::size_of::())); + + ioctl!(create_irqchip with io!(KVMIO, 0x60)); + + ioctl!(run with io!(KVMIO, 0x80)); + ioctl!(get_regs with ior!(KVMIO, 0x81, mem::size_of::())); + ioctl!(set_regs with iow!(KVMIO, 0x82, mem::size_of::())); + ioctl!(get_sregs with ior!(KVMIO, 0x83, mem::size_of::())); + ioctl!(set_sregs with iow!(KVMIO, 0x84, mem::size_of::())); + +} + +/// KVM is freezed at version 12, so all others are invalid +#[derive(Debug)] +pub enum Version{ + Version12, + Unsupported +} + +/// This is the entry point of our module, it connects to the KVM device and wraps the functions +/// which accept the global file descriptor. +pub struct Uhyve { + file: File +} + +impl Uhyve { + // Connects to the KVM hypervisor, by opening the virtual device /dev/kvm + pub fn new() -> Uhyve { + + let kvm_file = OpenOptions::new() + .read(true) + .write(true) + .custom_flags(libc::O_CLOEXEC) + .open("/dev/kvm").unwrap(); + + debug!("UHYVE - The connection to KVM was established."); + + Uhyve { file: kvm_file } + } + + // Acquires the KVM version to seperate ancient systems + pub fn version(&self) -> Result { + unsafe { + match ioctl::get_version(self.file.as_raw_fd(), ptr::null_mut()) { + Ok(12) => Ok(Version::Version12), + Ok(_) => Ok(Version::Unsupported), + Err(_) => Err(Error::InternalError) + } + } + } + + // Creates a new virtual machine and forwards the new fd to an object + pub fn create_vm(&self, size: usize) -> Result { + unsafe { + match ioctl::create_vm(self.file.as_raw_fd(), ptr::null_mut()) { + Ok(vm_fd) => VirtualMachine::new(self.file.as_raw_fd(), vm_fd, size), + Err(_) => Err(Error::InternalError) + } + } + + + } +} diff --git a/tools/hermit_proxy/src/uhyve/vcpu.rs b/tools/hermit_proxy/src/uhyve/vcpu.rs new file mode 100644 index 000000000..6a361694d --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/vcpu.rs @@ -0,0 +1,288 @@ +use libc; +use libc::{c_void, c_int}; +use std::{mem, ptr}; +use std::fs::File; +use std::os::unix::io::FromRawFd; +use memmap::{Mmap, Protection}; +use errno::errno; + +use uhyve; +use uhyve::kvm_header::{kvm_sregs, kvm_regs, kvm_segment, kvm_cpuid2}; +use uhyve::{Result, Error}; +use uhyve::gdt; +use uhyve::proto; + +pub const GUEST_OFFSET: usize = 0x0; +pub const CPUID_FUNC_PERFMON: usize = 0x0A; +pub const GUEST_PAGE_SIZE: usize = 0x200000; + +// TODO configuration missing +pub const GUEST_SIZE: usize = 0x20000000; + +pub const BOOT_GDT: usize = 0x1000; +pub const BOOT_INFO: usize = 0x2000; +pub const BOOT_PML4: usize = 0x10000; +pub const BOOT_PDPTE:usize = 0x11000; +pub const BOOT_PDE: usize = 0x12000; + +/// Basic CPU control in CR0 +pub const X86_CR0_PE: u64 = (1 << 0); +pub const X86_CR0_PG: u64 = (1 << 31); + +/// Intel long mode page directory/table entries +pub const X86_CR4_PAE: u64 = (1 << 0); + +/// Intel long mode page directory/table entries +pub const X86_PDPT_P: u64 = (1 << 0); +pub const X86_PDPT_RW: u64 = (1 << 1); +pub const X86_PDPT_PS: u64 = (1 << 7); + +pub struct VirtualCPU { + vm_fd: libc::c_int, + pub vcpu_fd: libc::c_int, + id: u8, + run_mem: Mmap +} + +impl VirtualCPU { + pub fn new(kvm_fd: libc::c_int, vm_fd: libc::c_int, id: u8, entry: u64, mem: &mut Mmap) -> Result { + debug!("UHYVE - New virtual CPU with id {}", id); + + // create a new VCPU and save the file descriptor + let fd = VirtualCPU::create_vcpu(vm_fd)?; + + debug!("Got fd {}", fd); + + let run_mem = unsafe { + Mmap::open_with_offset(&File::from_raw_fd(fd), Protection::ReadWrite, 0, VirtualCPU::get_mmap_size(kvm_fd)?) + .map_err(|x| panic!("{:?}", x) )//Error::InvalidFile) + }?; + + let cpu = VirtualCPU { + vm_fd: vm_fd, vcpu_fd: fd, id: id, run_mem: run_mem + }; + + if id == 0 { + debug!("Setup the first processor"); + + let mut mem = unsafe { + mem.as_mut_slice() + }; + + cpu.setup_first(&mut mem)?; + } + + debug!("Initialize the register of {}", id); + + let mut regs = kvm_regs::empty(); + regs.rip = entry; + regs.rflags = 0x2; + + cpu.set_regs(regs)?; + + cpu.setup_cpuid()?; + + Ok(cpu) + } + + pub fn create_vcpu(fd: c_int) -> Result { + unsafe { + uhyve::ioctl::create_vcpu(fd, ptr::null_mut()) + .map_err(|x| Error::FailedIOCTL(x)) + } + } + + pub fn get_sregs(&self) -> Result { + let mut sregs = kvm_sregs::empty(); + unsafe { + uhyve::ioctl::get_sregs(self.vcpu_fd, (&mut sregs) as *mut kvm_sregs as *mut u8) + .map_err(|x| Error::FailedIOCTL(x))?; + } + + Ok(sregs) + } + + pub fn set_sregs(&self, mut sregs: kvm_sregs) -> Result<()> { + unsafe { + uhyve::ioctl::set_sregs(self.vcpu_fd, (&mut sregs) as *mut kvm_sregs as *mut u8) + .map_err(|x| Error::FailedIOCTL(x))?; + } + + Ok(()) + } + + pub fn set_regs(&self, mut regs: kvm_regs) -> Result<()> { + unsafe { + uhyve::ioctl::set_regs(self.vcpu_fd, (&mut regs) as *mut kvm_regs as *mut u8) + .map_err(|x| Error::FailedIOCTL(x))?; + } + + Ok(()) + } + + pub fn get_supported_cpuid(&self) -> Result { + let mut cpuid = kvm_cpuid2::empty(); + unsafe { + uhyve::ioctl::get_supported_cpuid(self.vm_fd, (&mut cpuid) as *mut kvm_cpuid2 as *mut u8) + .map_err(|x| Error::FailedIOCTL(x))?; + } + + Ok(cpuid) + } + + pub fn set_cpuid2(&self, mut cpuid: kvm_cpuid2) -> Result<()> { + unsafe { + uhyve::ioctl::set_cpuid2(self.vm_fd, (&mut cpuid) as *mut kvm_cpuid2 as *mut u8) + .map_err(|x| Error::FailedIOCTL(x))?; + } + + Ok(()) + } + + pub fn get_mmap_size(vcpu_fd: libc::c_int) -> Result { + unsafe { + uhyve::ioctl::get_vcpu_mmap_size(vcpu_fd, ptr::null_mut()) + .map_err(|x| Error::FailedIOCTL(x)).map(|x| { debug!("MMAP size {}", x); x as usize }) + } + } + + pub fn single_run(&self, guest_mem: &mut [u8]) -> Result { + let ret = unsafe { + uhyve::ioctl::run(self.vcpu_fd, ptr::null_mut()) + .map_err(|x| Error::FailedIOCTL(x)) + }?; + + if ret == -1 { + match errno().0 { + libc::EINTR => { return Ok(ret); }, + libc::EFAULT => { + // TODO + panic!("translation fault!"); + }, + _ => { + panic!("KVM: ioctl KVM_RUN in vcpu_loop failed"); + } + } + } + + unsafe { + proto::Syscall::from_mem(self.run_mem.as_slice(), guest_mem).run(guest_mem.as_mut_ptr()); + } + + Ok(ret) + } + + pub fn run(&self, guest_mem: &mut [u8]) -> Result { + loop { + self.single_run(guest_mem)?; + } + } + + pub fn setup_first(&self, mem: &mut [u8]) -> Result<()> { + // This is a fatal fault, so we will abort here + if self.id != 0 { + panic!("Shouldn't be called by any other processor than the first!"); + } + + let mut sregs = self.get_sregs()?; + + debug!("Setup GDT"); + self.setup_system_gdt(&mut sregs, mem, 0)?; + debug!("Setup the page table"); + self.setup_system_page_table(&mut sregs, mem)?; + debug!("Set the system to 64bit"); + self.setup_system_64bit(&mut sregs)?; + + self.set_sregs(sregs)?; + + Ok(()) + } + + pub fn setup_system_gdt(&self, sregs: &mut kvm_sregs, mem: &mut [u8], offset: u64) -> Result<()> { + let (mut data_seg, mut code_seg) = (kvm_segment::empty(), kvm_segment::empty()); + + // create the GDT entries + let gdt_null = gdt::Entry::new(0, 0, 0); + let gdt_code = gdt::Entry::new(0xA09B, 0, 0xFFFFF); + let gdt_data = gdt::Entry::new(0xC093, 0, 0xFFFFF); + + // apply the new GDTs to our guest memory + let ptr = mem[offset as usize..].as_ptr() as *mut u64; + unsafe { + *(ptr.offset(gdt::BOOT_NULL)) = gdt_null.as_u64(); + *(ptr.offset(gdt::BOOT_CODE)) = gdt_code.as_u64(); + *(ptr.offset(gdt::BOOT_DATA)) = gdt_code.as_u64(); + } + + gdt_code.apply_to_kvm(gdt::BOOT_CODE, &mut code_seg); + gdt_data.apply_to_kvm(gdt::BOOT_DATA, &mut data_seg); + + sregs.gdt.base = offset; + sregs.gdt.limit = ((mem::size_of::() * gdt::BOOT_MAX) - 1) as u16; + sregs.cs = code_seg; + sregs.ds = data_seg; + sregs.es = data_seg; + sregs.fs = data_seg; + sregs.gs = data_seg; + sregs.ss = data_seg; + + Ok(()) + } + pub fn setup_system_page_table(&self, sregs: &mut kvm_sregs, mem: &mut [u8]) -> Result<()> { + let pml4 = mem[BOOT_PML4..].as_ptr() as *mut u64; + let pdpte = mem[BOOT_PDPTE..].as_ptr() as *mut u64; + let pde = mem[BOOT_PDE..].as_ptr() as *mut u64; + + // TODO + //assert!((guest_size & (GUEST_PAGE_SIZE - 1)) == 0); + //assert!(guest_size <= (GUEST_PAGE_SIZE * 512)); + + unsafe { + libc::memset(pml4 as *mut c_void, 0x00, 4096); + libc::memset(pdpte as *mut c_void, 0x00, 4096); + libc::memset(pde as *mut c_void, 0x00, 4096); + + *pml4 = (BOOT_PDPTE as u64) | (X86_PDPT_P | X86_PDPT_RW); + *pdpte = (BOOT_PDE as u64) | (X86_PDPT_P | X86_PDPT_RW); + + for i in 0..(GUEST_SIZE/GUEST_PAGE_SIZE) { + *(pde.offset(i as isize)) = (i*GUEST_PAGE_SIZE) as u64 | (X86_PDPT_P | X86_PDPT_RW | X86_PDPT_PS); + } + } + + sregs.cr3 = BOOT_PML4 as u64; + sregs.cr4 |= X86_CR4_PAE; + sregs.cr0 |= X86_CR0_PG; + + Ok(()) + } + + pub fn setup_system_64bit(&self, sregs: &mut kvm_sregs) -> Result<()> { + sregs.cr0 |= X86_CR0_PE; + sregs.efer |= 1 << 8; + + Ok(()) + } + + pub fn setup_cpuid(&self) -> Result<()> { + let mut kvm_cpuid = self.get_supported_cpuid()?; + + for entry in kvm_cpuid.entries.iter_mut() { + match entry.function { + 1 => { + entry.ecx |= 1u32 << 31; // propagate that we are running on a hypervisor + entry.edx |= 1u32 << 5; // enable msr support + }, + 0x0A => { + // disable it + entry.eax = 0x00; + }, + _ => {} + } + } + + self.set_cpuid2(kvm_cpuid)?; + + Ok(()) + } +} diff --git a/tools/hermit_proxy/src/uhyve/vm.rs b/tools/hermit_proxy/src/uhyve/vm.rs new file mode 100644 index 000000000..62faa9724 --- /dev/null +++ b/tools/hermit_proxy/src/uhyve/vm.rs @@ -0,0 +1,148 @@ +//! By calling create_vm KVM returns a fd, this file wraps all relevant functions belonging to the +//! VM layer + +use libc; +use std::ptr; +use std::fs::File; +use std::io::{Read, Cursor}; +use memmap::{Mmap, Protection}; +use elf; +use elf::types::{ELFCLASS64, OSABI, PT_LOAD}; + +use utils; +use uhyve; +use uhyve::kvm_header::{kvm_userspace_memory_region }; +use uhyve::{Result, Error}; +use uhyve::vcpu::VirtualCPU; + +//use byteorder::ByteOrder; +// guest offset? +//pub const GUEST_OFFSET = 0; + +pub struct VirtualMachine { + kvm_fd: libc::c_int, + vm_fd: libc::c_int, + mem: Mmap, + elf_entry: Option, + vcpus: Vec, + size: usize +} + +impl VirtualMachine { + pub fn new(kvm_fd: libc::c_int, fd: libc::c_int, size: usize) -> Result { + debug!("UHYVE - New virtual machine with memory size {}", size); + + // create a new memory region to map the memory of our guest + Mmap::anonymous(size, Protection::ReadWrite) + .map_err(|_| Error::NotEnoughMemory) + .map(|mem| VirtualMachine { kvm_fd: kvm_fd, vm_fd: fd, mem: mem, elf_entry: None, vcpus: Vec::new(), size: size }) + } + + /// Loads a kernel from path and initialite mem and elf_entry + pub fn load_kernel(&mut self, path: &str) -> Result<()> { + debug!("UHYVE - Load kernel from {}", path); + + // open the file in read only + let file = Mmap::open_path(path, Protection::Read).map_err(|_| Error::InvalidFile)?; + + // parse the header with ELF module + let file_efi = { + let mut data = unsafe { Cursor::new(file.as_slice()) }; + + elf::File::open_stream(&mut data).map_err(|_| Error::InvalidFile) + }?; + + if file_efi.ehdr.class != ELFCLASS64 || file_efi.ehdr.osabi != OSABI(0x42) { + return Err(Error::InvalidFile); + } + + self.elf_entry = Some(file_efi.ehdr.entry); + + // acquire the slices of the user memory and kernel file + let vm_mem_length = self.mem.len() as u64; + let vm_mem = unsafe { self.mem.as_mut_slice() }; + let kernel_file = unsafe { file.as_slice() }; + + for header in file_efi.phdrs { + if header.progtype != PT_LOAD { + continue; + } + + let vm_start = header.paddr as usize; + let vm_end = vm_start + header.filesz as usize; + + let kernel_start = header.offset as usize; + let kernel_end = kernel_start + header.filesz as usize; + + debug!("Load segment with start addr {} and size {} to {}", header.paddr, header.filesz, header.offset); + + vm_mem[vm_start..vm_end].copy_from_slice(&kernel_file[kernel_start..kernel_end]); + + let ptr = vm_mem[vm_start..vm_end].as_mut_ptr(); + + unsafe { + *(ptr.offset(0x08) as *mut u64) = header.paddr; // physical start addr + *(ptr.offset(0x10) as *mut u64) = vm_mem_length; // physical size limit + *(ptr.offset(0x18) as *mut u32) = utils::cpufreq()?; // CPU frequency + *(ptr.offset(0x24) as *mut u32) = 1; // number of used CPUs + *(ptr.offset(0x30) as *mut u32) = 0; // apicid (?) + *(ptr.offset(0x38) as *mut u64) = header.filesz; // + *(ptr.offset(0x60) as *mut u32) = 1; // NUMA nodes + *(ptr.offset(0x94) as *mut u32) = 1; // announce uhyve + } + } + + debug!("Kernel loaded"); + + Ok(()) + } + + /// Initialize the virtual machine + pub fn init(&mut self) -> Result<()> { + let start_ptr = unsafe { self.mem.as_slice().as_ptr() as u64 }; + let kvm_region = kvm_userspace_memory_region { + slot: 0, guest_phys_addr: 0, flags: 0, memory_size: self.mem.len() as u64, userspace_addr: start_ptr + }; + + self.set_user_memory_region(kvm_region)?; + self.create_irqchip()?; + let vcpu = self.create_vcpu(0)?; + + self.vcpus.push(vcpu); + + Ok(()) + } + + pub fn set_user_memory_region(&self, mut region: kvm_userspace_memory_region) -> Result<()> { + unsafe { + let p: *mut kvm_userspace_memory_region = &mut region; + uhyve::ioctl::set_user_memory_region(self.vm_fd, p as *mut u8) + .map_err(|x| Error::FailedIOCTL(x)).map(|_| ()) + } + } + + pub fn create_irqchip(&self) -> Result<()> { + unsafe { + uhyve::ioctl::create_irqchip(self.vm_fd, ptr::null_mut()) + .map_err(|x| Error::FailedIOCTL(x)).map(|_| ()) + } + } + + pub fn create_vcpu(&mut self, id: u8) -> Result { + let entry = self.elf_entry.ok_or(Error::KernelNotLoaded)?; + + let cpu = VirtualCPU::new(self.kvm_fd, self.vm_fd, id, entry, &mut self.mem)?; + + Ok(cpu) + } + + pub fn run(&mut self) -> Result<()> { + let mut guest_mem = unsafe { self.mem.as_mut_slice() }; + + for vcpu in &self.vcpus { + vcpu.run(&mut guest_mem)?; + } + + Ok(()) + } +} diff --git a/tools/hermit_proxy/src/utils.rs b/tools/hermit_proxy/src/utils.rs new file mode 100644 index 000000000..fa8dfc683 --- /dev/null +++ b/tools/hermit_proxy/src/utils.rs @@ -0,0 +1,65 @@ +use std::fs::File; +use std::os::unix::io::FromRawFd; +use std::ffi::CString; +use std::io::Read; + +use error::*; + +use libc; + +/// Returns the cpu frequency +pub fn cpufreq() -> Result { + let mut content = String::new(); + + // If the file cpuinfo_max_freq exists, parse the content and return the frequency + if let Ok(mut file) = File::open("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq") { + file.read_to_string(&mut content).unwrap(); + return content.trim().parse::().map_err(|_| Error::MissingFrequency); + } + // otherwise use the more acurate cpuinfo file and search for the right line + else if let Ok(mut file) = File::open("/proc/cpuinfo") { + file.read_to_string(&mut content).expect("Couldnt read!"); + + for line in content.lines() { + if line.starts_with("cpu MHz") { + return line.split(':').skip(1).next().unwrap().trim().parse::().map_err(|_| Error::MissingFrequency).map(|x| x as u32); + } + } + } + + // ups shouldn't happened .. + Err(Error::MissingFrequency) +} + +/// Creates a temporary file /tmp/-XXXX, the X will be replaced by an arbitrary sequence +pub fn create_tmp_file(name: &str) -> Result { + unsafe { + let c_str = CString::new(name).unwrap(); + let raw = c_str.into_raw(); + let res = libc::mkstemp(raw); + + if res < 0 { + return Err(Error::CannotCreateTmpFile(res as usize)); + } + + let new_name = CString::from_raw(raw).into_string().unwrap(); + + debug!("UTILS - Created tmp file with name {}", new_name); + + Ok(new_name) + } +} + +/// Deletes a temporary file +pub fn delete_tmp_file(name: &str) -> Result<()> { + unsafe { + let c_str = CString::new(name).unwrap(); + let res = libc::unlink(c_str.into_raw()); + + if res < 0 { + return Err(Error::InvalidFile); + } else { + return Ok(()); + } + } +}