diff --git a/Cargo.toml b/Cargo.toml index ffd0322..0e4d739 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,11 +9,9 @@ license-file = "LICENSE" [dependencies] libc = "0.2" -protobuf = "2.27.1" anyhow = "1.0.56" - -[build-dependencies] -protobuf-codegen-pure = "2.25.2" +protobuf = "3.2.0" +rust-criu-protobuf = { path = "rust-criu-protobuf" } [lib] name = "rust_criu" diff --git a/build.rs b/build.rs index 5a189fd..a1f5df0 100644 --- a/build.rs +++ b/build.rs @@ -1,15 +1,7 @@ -extern crate protobuf_codegen_pure; - fn main() { - protobuf_codegen_pure::Codegen::new() - .out_dir("src/proto") - .inputs(["proto/rpc.proto"]) - .include("proto") - .run() - .expect("Codegen failed."); - std::process::Command::new("gcc") .args(["test/piggie.c", "-o", "test/piggie"]) .status() .unwrap(); + println!("cargo:rerun-if-changed=test/piggie.c"); } diff --git a/rust-criu-protobuf/Cargo.toml b/rust-criu-protobuf/Cargo.toml new file mode 100644 index 0000000..9704a77 --- /dev/null +++ b/rust-criu-protobuf/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "rust-criu-protobuf" +version = "0.1.0" +edition = "2021" + +[dependencies] +protobuf = "3.2.0" + +[build-dependencies] +protobuf-codegen = "3.2.0" + +[lib] +name = "rust_criu_protobuf" +path = "src/mod.rs" diff --git a/rust-criu-protobuf/build.rs b/rust-criu-protobuf/build.rs new file mode 100644 index 0000000..c48e3f5 --- /dev/null +++ b/rust-criu-protobuf/build.rs @@ -0,0 +1,11 @@ +extern crate protobuf_codegen; + +fn main() { + protobuf_codegen::Codegen::new() + .includes(["proto"]) + .input("proto/rpc.proto") + .out_dir("src") + .run_from_script(); + + println!("cargo:rerun-if-changed=proto/rpc.proto"); +} diff --git a/proto/rpc.proto b/rust-criu-protobuf/proto/rpc.proto similarity index 100% rename from proto/rpc.proto rename to rust-criu-protobuf/proto/rpc.proto diff --git a/rust-criu-protobuf/src/mod.rs b/rust-criu-protobuf/src/mod.rs new file mode 100644 index 0000000..f508e06 --- /dev/null +++ b/rust-criu-protobuf/src/mod.rs @@ -0,0 +1,3 @@ +// @generated + +pub mod rpc; diff --git a/rust-criu-protobuf/src/rpc.rs b/rust-criu-protobuf/src/rpc.rs new file mode 100644 index 0000000..0bde113 --- /dev/null +++ b/rust-criu-protobuf/src/rpc.rs @@ -0,0 +1,6209 @@ +// This file is generated by rust-protobuf 3.2.0. Do not edit +// .proto file is parsed by protoc 3.19.4 +// @generated + +// https://github.com/rust-lang/rust-clippy/issues/702 +#![allow(unknown_lints)] +#![allow(clippy::all)] + +#![allow(unused_attributes)] +#![cfg_attr(rustfmt, rustfmt::skip)] + +#![allow(box_pointers)] +#![allow(dead_code)] +#![allow(missing_docs)] +#![allow(non_camel_case_types)] +#![allow(non_snake_case)] +#![allow(non_upper_case_globals)] +#![allow(trivial_casts)] +#![allow(unused_results)] +#![allow(unused_mut)] + +//! Generated file from `rpc.proto` + +/// Generated files are compatible only with the same version +/// of protobuf runtime. +const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0; + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_page_server_info) +pub struct Criu_page_server_info { + // message fields + // @@protoc_insertion_point(field:criu_page_server_info.address) + pub address: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_page_server_info.port) + pub port: ::std::option::Option, + // @@protoc_insertion_point(field:criu_page_server_info.pid) + pub pid: ::std::option::Option, + // @@protoc_insertion_point(field:criu_page_server_info.fd) + pub fd: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_page_server_info.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_page_server_info { + fn default() -> &'a Criu_page_server_info { + ::default_instance() + } +} + +impl Criu_page_server_info { + pub fn new() -> Criu_page_server_info { + ::std::default::Default::default() + } + + // optional string address = 1; + + pub fn address(&self) -> &str { + match self.address.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_address(&mut self) { + self.address = ::std::option::Option::None; + } + + pub fn has_address(&self) -> bool { + self.address.is_some() + } + + // Param is passed by value, moved + pub fn set_address(&mut self, v: ::std::string::String) { + self.address = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_address(&mut self) -> &mut ::std::string::String { + if self.address.is_none() { + self.address = ::std::option::Option::Some(::std::string::String::new()); + } + self.address.as_mut().unwrap() + } + + // Take field + pub fn take_address(&mut self) -> ::std::string::String { + self.address.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional int32 port = 2; + + pub fn port(&self) -> i32 { + self.port.unwrap_or(0) + } + + pub fn clear_port(&mut self) { + self.port = ::std::option::Option::None; + } + + pub fn has_port(&self) -> bool { + self.port.is_some() + } + + // Param is passed by value, moved + pub fn set_port(&mut self, v: i32) { + self.port = ::std::option::Option::Some(v); + } + + // optional int32 pid = 3; + + pub fn pid(&self) -> i32 { + self.pid.unwrap_or(0) + } + + pub fn clear_pid(&mut self) { + self.pid = ::std::option::Option::None; + } + + pub fn has_pid(&self) -> bool { + self.pid.is_some() + } + + // Param is passed by value, moved + pub fn set_pid(&mut self, v: i32) { + self.pid = ::std::option::Option::Some(v); + } + + // optional int32 fd = 4; + + pub fn fd(&self) -> i32 { + self.fd.unwrap_or(0) + } + + pub fn clear_fd(&mut self) { + self.fd = ::std::option::Option::None; + } + + pub fn has_fd(&self) -> bool { + self.fd.is_some() + } + + // Param is passed by value, moved + pub fn set_fd(&mut self, v: i32) { + self.fd = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(4); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "address", + |m: &Criu_page_server_info| { &m.address }, + |m: &mut Criu_page_server_info| { &mut m.address }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "port", + |m: &Criu_page_server_info| { &m.port }, + |m: &mut Criu_page_server_info| { &mut m.port }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pid", + |m: &Criu_page_server_info| { &m.pid }, + |m: &mut Criu_page_server_info| { &mut m.pid }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "fd", + |m: &Criu_page_server_info| { &m.fd }, + |m: &mut Criu_page_server_info| { &mut m.fd }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_page_server_info", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_page_server_info { + const NAME: &'static str = "criu_page_server_info"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.address = ::std::option::Option::Some(is.read_string()?); + }, + 16 => { + self.port = ::std::option::Option::Some(is.read_int32()?); + }, + 24 => { + self.pid = ::std::option::Option::Some(is.read_int32()?); + }, + 32 => { + self.fd = ::std::option::Option::Some(is.read_int32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.address.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.port { + my_size += ::protobuf::rt::int32_size(2, v); + } + if let Some(v) = self.pid { + my_size += ::protobuf::rt::int32_size(3, v); + } + if let Some(v) = self.fd { + my_size += ::protobuf::rt::int32_size(4, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.address.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.port { + os.write_int32(2, v)?; + } + if let Some(v) = self.pid { + os.write_int32(3, v)?; + } + if let Some(v) = self.fd { + os.write_int32(4, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_page_server_info { + Criu_page_server_info::new() + } + + fn clear(&mut self) { + self.address = ::std::option::Option::None; + self.port = ::std::option::Option::None; + self.pid = ::std::option::Option::None; + self.fd = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_page_server_info { + static instance: Criu_page_server_info = Criu_page_server_info { + address: ::std::option::Option::None, + port: ::std::option::Option::None, + pid: ::std::option::Option::None, + fd: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_page_server_info { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_page_server_info").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_page_server_info { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_page_server_info { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_veth_pair) +pub struct Criu_veth_pair { + // message fields + // @@protoc_insertion_point(field:criu_veth_pair.if_in) + pub if_in: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_veth_pair.if_out) + pub if_out: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:criu_veth_pair.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_veth_pair { + fn default() -> &'a Criu_veth_pair { + ::default_instance() + } +} + +impl Criu_veth_pair { + pub fn new() -> Criu_veth_pair { + ::std::default::Default::default() + } + + // required string if_in = 1; + + pub fn if_in(&self) -> &str { + match self.if_in.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_if_in(&mut self) { + self.if_in = ::std::option::Option::None; + } + + pub fn has_if_in(&self) -> bool { + self.if_in.is_some() + } + + // Param is passed by value, moved + pub fn set_if_in(&mut self, v: ::std::string::String) { + self.if_in = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_if_in(&mut self) -> &mut ::std::string::String { + if self.if_in.is_none() { + self.if_in = ::std::option::Option::Some(::std::string::String::new()); + } + self.if_in.as_mut().unwrap() + } + + // Take field + pub fn take_if_in(&mut self) -> ::std::string::String { + self.if_in.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required string if_out = 2; + + pub fn if_out(&self) -> &str { + match self.if_out.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_if_out(&mut self) { + self.if_out = ::std::option::Option::None; + } + + pub fn has_if_out(&self) -> bool { + self.if_out.is_some() + } + + // Param is passed by value, moved + pub fn set_if_out(&mut self, v: ::std::string::String) { + self.if_out = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_if_out(&mut self) -> &mut ::std::string::String { + if self.if_out.is_none() { + self.if_out = ::std::option::Option::Some(::std::string::String::new()); + } + self.if_out.as_mut().unwrap() + } + + // Take field + pub fn take_if_out(&mut self) -> ::std::string::String { + self.if_out.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "if_in", + |m: &Criu_veth_pair| { &m.if_in }, + |m: &mut Criu_veth_pair| { &mut m.if_in }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "if_out", + |m: &Criu_veth_pair| { &m.if_out }, + |m: &mut Criu_veth_pair| { &mut m.if_out }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_veth_pair", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_veth_pair { + const NAME: &'static str = "criu_veth_pair"; + + fn is_initialized(&self) -> bool { + if self.if_in.is_none() { + return false; + } + if self.if_out.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.if_in = ::std::option::Option::Some(is.read_string()?); + }, + 18 => { + self.if_out = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.if_in.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.if_out.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.if_in.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.if_out.as_ref() { + os.write_string(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_veth_pair { + Criu_veth_pair::new() + } + + fn clear(&mut self) { + self.if_in = ::std::option::Option::None; + self.if_out = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_veth_pair { + static instance: Criu_veth_pair = Criu_veth_pair { + if_in: ::std::option::Option::None, + if_out: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_veth_pair { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_veth_pair").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_veth_pair { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_veth_pair { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:ext_mount_map) +pub struct Ext_mount_map { + // message fields + // @@protoc_insertion_point(field:ext_mount_map.key) + pub key: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:ext_mount_map.val) + pub val: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:ext_mount_map.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Ext_mount_map { + fn default() -> &'a Ext_mount_map { + ::default_instance() + } +} + +impl Ext_mount_map { + pub fn new() -> Ext_mount_map { + ::std::default::Default::default() + } + + // required string key = 1; + + pub fn key(&self) -> &str { + match self.key.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_key(&mut self) { + self.key = ::std::option::Option::None; + } + + pub fn has_key(&self) -> bool { + self.key.is_some() + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::string::String) { + self.key = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::string::String { + if self.key.is_none() { + self.key = ::std::option::Option::Some(::std::string::String::new()); + } + self.key.as_mut().unwrap() + } + + // Take field + pub fn take_key(&mut self) -> ::std::string::String { + self.key.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required string val = 2; + + pub fn val(&self) -> &str { + match self.val.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_val(&mut self) { + self.val = ::std::option::Option::None; + } + + pub fn has_val(&self) -> bool { + self.val.is_some() + } + + // Param is passed by value, moved + pub fn set_val(&mut self, v: ::std::string::String) { + self.val = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_val(&mut self) -> &mut ::std::string::String { + if self.val.is_none() { + self.val = ::std::option::Option::Some(::std::string::String::new()); + } + self.val.as_mut().unwrap() + } + + // Take field + pub fn take_val(&mut self) -> ::std::string::String { + self.val.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "key", + |m: &Ext_mount_map| { &m.key }, + |m: &mut Ext_mount_map| { &mut m.key }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "val", + |m: &Ext_mount_map| { &m.val }, + |m: &mut Ext_mount_map| { &mut m.val }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "ext_mount_map", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Ext_mount_map { + const NAME: &'static str = "ext_mount_map"; + + fn is_initialized(&self) -> bool { + if self.key.is_none() { + return false; + } + if self.val.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.key = ::std::option::Option::Some(is.read_string()?); + }, + 18 => { + self.val = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.key.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.val.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.key.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.val.as_ref() { + os.write_string(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Ext_mount_map { + Ext_mount_map::new() + } + + fn clear(&mut self) { + self.key = ::std::option::Option::None; + self.val = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Ext_mount_map { + static instance: Ext_mount_map = Ext_mount_map { + key: ::std::option::Option::None, + val: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Ext_mount_map { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("ext_mount_map").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Ext_mount_map { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Ext_mount_map { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:join_namespace) +pub struct Join_namespace { + // message fields + // @@protoc_insertion_point(field:join_namespace.ns) + pub ns: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:join_namespace.ns_file) + pub ns_file: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:join_namespace.extra_opt) + pub extra_opt: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:join_namespace.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Join_namespace { + fn default() -> &'a Join_namespace { + ::default_instance() + } +} + +impl Join_namespace { + pub fn new() -> Join_namespace { + ::std::default::Default::default() + } + + // required string ns = 1; + + pub fn ns(&self) -> &str { + match self.ns.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_ns(&mut self) { + self.ns = ::std::option::Option::None; + } + + pub fn has_ns(&self) -> bool { + self.ns.is_some() + } + + // Param is passed by value, moved + pub fn set_ns(&mut self, v: ::std::string::String) { + self.ns = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ns(&mut self) -> &mut ::std::string::String { + if self.ns.is_none() { + self.ns = ::std::option::Option::Some(::std::string::String::new()); + } + self.ns.as_mut().unwrap() + } + + // Take field + pub fn take_ns(&mut self) -> ::std::string::String { + self.ns.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required string ns_file = 2; + + pub fn ns_file(&self) -> &str { + match self.ns_file.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_ns_file(&mut self) { + self.ns_file = ::std::option::Option::None; + } + + pub fn has_ns_file(&self) -> bool { + self.ns_file.is_some() + } + + // Param is passed by value, moved + pub fn set_ns_file(&mut self, v: ::std::string::String) { + self.ns_file = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ns_file(&mut self) -> &mut ::std::string::String { + if self.ns_file.is_none() { + self.ns_file = ::std::option::Option::Some(::std::string::String::new()); + } + self.ns_file.as_mut().unwrap() + } + + // Take field + pub fn take_ns_file(&mut self) -> ::std::string::String { + self.ns_file.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string extra_opt = 3; + + pub fn extra_opt(&self) -> &str { + match self.extra_opt.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_extra_opt(&mut self) { + self.extra_opt = ::std::option::Option::None; + } + + pub fn has_extra_opt(&self) -> bool { + self.extra_opt.is_some() + } + + // Param is passed by value, moved + pub fn set_extra_opt(&mut self, v: ::std::string::String) { + self.extra_opt = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_extra_opt(&mut self) -> &mut ::std::string::String { + if self.extra_opt.is_none() { + self.extra_opt = ::std::option::Option::Some(::std::string::String::new()); + } + self.extra_opt.as_mut().unwrap() + } + + // Take field + pub fn take_extra_opt(&mut self) -> ::std::string::String { + self.extra_opt.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(3); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ns", + |m: &Join_namespace| { &m.ns }, + |m: &mut Join_namespace| { &mut m.ns }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ns_file", + |m: &Join_namespace| { &m.ns_file }, + |m: &mut Join_namespace| { &mut m.ns_file }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "extra_opt", + |m: &Join_namespace| { &m.extra_opt }, + |m: &mut Join_namespace| { &mut m.extra_opt }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "join_namespace", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Join_namespace { + const NAME: &'static str = "join_namespace"; + + fn is_initialized(&self) -> bool { + if self.ns.is_none() { + return false; + } + if self.ns_file.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.ns = ::std::option::Option::Some(is.read_string()?); + }, + 18 => { + self.ns_file = ::std::option::Option::Some(is.read_string()?); + }, + 26 => { + self.extra_opt = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.ns.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.ns_file.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + if let Some(v) = self.extra_opt.as_ref() { + my_size += ::protobuf::rt::string_size(3, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.ns.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.ns_file.as_ref() { + os.write_string(2, v)?; + } + if let Some(v) = self.extra_opt.as_ref() { + os.write_string(3, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Join_namespace { + Join_namespace::new() + } + + fn clear(&mut self) { + self.ns = ::std::option::Option::None; + self.ns_file = ::std::option::Option::None; + self.extra_opt = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Join_namespace { + static instance: Join_namespace = Join_namespace { + ns: ::std::option::Option::None, + ns_file: ::std::option::Option::None, + extra_opt: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Join_namespace { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("join_namespace").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Join_namespace { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Join_namespace { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:inherit_fd) +pub struct Inherit_fd { + // message fields + // @@protoc_insertion_point(field:inherit_fd.key) + pub key: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:inherit_fd.fd) + pub fd: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:inherit_fd.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Inherit_fd { + fn default() -> &'a Inherit_fd { + ::default_instance() + } +} + +impl Inherit_fd { + pub fn new() -> Inherit_fd { + ::std::default::Default::default() + } + + // required string key = 1; + + pub fn key(&self) -> &str { + match self.key.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_key(&mut self) { + self.key = ::std::option::Option::None; + } + + pub fn has_key(&self) -> bool { + self.key.is_some() + } + + // Param is passed by value, moved + pub fn set_key(&mut self, v: ::std::string::String) { + self.key = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_key(&mut self) -> &mut ::std::string::String { + if self.key.is_none() { + self.key = ::std::option::Option::Some(::std::string::String::new()); + } + self.key.as_mut().unwrap() + } + + // Take field + pub fn take_key(&mut self) -> ::std::string::String { + self.key.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required int32 fd = 2; + + pub fn fd(&self) -> i32 { + self.fd.unwrap_or(0) + } + + pub fn clear_fd(&mut self) { + self.fd = ::std::option::Option::None; + } + + pub fn has_fd(&self) -> bool { + self.fd.is_some() + } + + // Param is passed by value, moved + pub fn set_fd(&mut self, v: i32) { + self.fd = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "key", + |m: &Inherit_fd| { &m.key }, + |m: &mut Inherit_fd| { &mut m.key }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "fd", + |m: &Inherit_fd| { &m.fd }, + |m: &mut Inherit_fd| { &mut m.fd }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "inherit_fd", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Inherit_fd { + const NAME: &'static str = "inherit_fd"; + + fn is_initialized(&self) -> bool { + if self.key.is_none() { + return false; + } + if self.fd.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.key = ::std::option::Option::Some(is.read_string()?); + }, + 16 => { + self.fd = ::std::option::Option::Some(is.read_int32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.key.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.fd { + my_size += ::protobuf::rt::int32_size(2, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.key.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.fd { + os.write_int32(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Inherit_fd { + Inherit_fd::new() + } + + fn clear(&mut self) { + self.key = ::std::option::Option::None; + self.fd = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Inherit_fd { + static instance: Inherit_fd = Inherit_fd { + key: ::std::option::Option::None, + fd: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Inherit_fd { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("inherit_fd").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Inherit_fd { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Inherit_fd { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:cgroup_root) +pub struct Cgroup_root { + // message fields + // @@protoc_insertion_point(field:cgroup_root.ctrl) + pub ctrl: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:cgroup_root.path) + pub path: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:cgroup_root.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Cgroup_root { + fn default() -> &'a Cgroup_root { + ::default_instance() + } +} + +impl Cgroup_root { + pub fn new() -> Cgroup_root { + ::std::default::Default::default() + } + + // optional string ctrl = 1; + + pub fn ctrl(&self) -> &str { + match self.ctrl.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_ctrl(&mut self) { + self.ctrl = ::std::option::Option::None; + } + + pub fn has_ctrl(&self) -> bool { + self.ctrl.is_some() + } + + // Param is passed by value, moved + pub fn set_ctrl(&mut self, v: ::std::string::String) { + self.ctrl = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_ctrl(&mut self) -> &mut ::std::string::String { + if self.ctrl.is_none() { + self.ctrl = ::std::option::Option::Some(::std::string::String::new()); + } + self.ctrl.as_mut().unwrap() + } + + // Take field + pub fn take_ctrl(&mut self) -> ::std::string::String { + self.ctrl.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // required string path = 2; + + pub fn path(&self) -> &str { + match self.path.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_path(&mut self) { + self.path = ::std::option::Option::None; + } + + pub fn has_path(&self) -> bool { + self.path.is_some() + } + + // Param is passed by value, moved + pub fn set_path(&mut self, v: ::std::string::String) { + self.path = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_path(&mut self) -> &mut ::std::string::String { + if self.path.is_none() { + self.path = ::std::option::Option::Some(::std::string::String::new()); + } + self.path.as_mut().unwrap() + } + + // Take field + pub fn take_path(&mut self) -> ::std::string::String { + self.path.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ctrl", + |m: &Cgroup_root| { &m.ctrl }, + |m: &mut Cgroup_root| { &mut m.ctrl }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "path", + |m: &Cgroup_root| { &m.path }, + |m: &mut Cgroup_root| { &mut m.path }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "cgroup_root", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Cgroup_root { + const NAME: &'static str = "cgroup_root"; + + fn is_initialized(&self) -> bool { + if self.path.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.ctrl = ::std::option::Option::Some(is.read_string()?); + }, + 18 => { + self.path = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.ctrl.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.path.as_ref() { + my_size += ::protobuf::rt::string_size(2, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.ctrl.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.path.as_ref() { + os.write_string(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Cgroup_root { + Cgroup_root::new() + } + + fn clear(&mut self) { + self.ctrl = ::std::option::Option::None; + self.path = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Cgroup_root { + static instance: Cgroup_root = Cgroup_root { + ctrl: ::std::option::Option::None, + path: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Cgroup_root { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("cgroup_root").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Cgroup_root { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Cgroup_root { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:unix_sk) +pub struct Unix_sk { + // message fields + // @@protoc_insertion_point(field:unix_sk.inode) + pub inode: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:unix_sk.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Unix_sk { + fn default() -> &'a Unix_sk { + ::default_instance() + } +} + +impl Unix_sk { + pub fn new() -> Unix_sk { + ::std::default::Default::default() + } + + // required uint32 inode = 1; + + pub fn inode(&self) -> u32 { + self.inode.unwrap_or(0) + } + + pub fn clear_inode(&mut self) { + self.inode = ::std::option::Option::None; + } + + pub fn has_inode(&self) -> bool { + self.inode.is_some() + } + + // Param is passed by value, moved + pub fn set_inode(&mut self, v: u32) { + self.inode = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(1); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "inode", + |m: &Unix_sk| { &m.inode }, + |m: &mut Unix_sk| { &mut m.inode }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "unix_sk", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Unix_sk { + const NAME: &'static str = "unix_sk"; + + fn is_initialized(&self) -> bool { + if self.inode.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.inode = ::std::option::Option::Some(is.read_uint32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.inode { + my_size += ::protobuf::rt::uint32_size(1, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.inode { + os.write_uint32(1, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Unix_sk { + Unix_sk::new() + } + + fn clear(&mut self) { + self.inode = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Unix_sk { + static instance: Unix_sk = Unix_sk { + inode: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Unix_sk { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("unix_sk").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Unix_sk { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Unix_sk { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_opts) +pub struct Criu_opts { + // message fields + // @@protoc_insertion_point(field:criu_opts.images_dir_fd) + pub images_dir_fd: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.pid) + pub pid: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.leave_running) + pub leave_running: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.ext_unix_sk) + pub ext_unix_sk: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.tcp_established) + pub tcp_established: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.evasive_devices) + pub evasive_devices: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.shell_job) + pub shell_job: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.file_locks) + pub file_locks: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.log_level) + pub log_level: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.log_file) + pub log_file: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.ps) + pub ps: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_opts.notify_scripts) + pub notify_scripts: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.root) + pub root: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.parent_img) + pub parent_img: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.track_mem) + pub track_mem: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.auto_dedup) + pub auto_dedup: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.work_dir_fd) + pub work_dir_fd: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.link_remap) + pub link_remap: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.veths) + pub veths: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.cpu_cap) + pub cpu_cap: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.force_irmap) + pub force_irmap: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.exec_cmd) + pub exec_cmd: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.ext_mnt) + pub ext_mnt: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.manage_cgroups) + pub manage_cgroups: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.cg_root) + pub cg_root: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.rst_sibling) + pub rst_sibling: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.inherit_fd) + pub inherit_fd: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.auto_ext_mnt) + pub auto_ext_mnt: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.ext_sharing) + pub ext_sharing: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.ext_masters) + pub ext_masters: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.skip_mnt) + pub skip_mnt: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.enable_fs) + pub enable_fs: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.unix_sk_ino) + pub unix_sk_ino: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.manage_cgroups_mode) + pub manage_cgroups_mode: ::std::option::Option<::protobuf::EnumOrUnknown>, + // @@protoc_insertion_point(field:criu_opts.ghost_limit) + pub ghost_limit: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.irmap_scan_paths) + pub irmap_scan_paths: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.external) + pub external: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.empty_ns) + pub empty_ns: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.join_ns) + pub join_ns: ::std::vec::Vec, + // @@protoc_insertion_point(field:criu_opts.cgroup_props) + pub cgroup_props: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.cgroup_props_file) + pub cgroup_props_file: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.cgroup_dump_controller) + pub cgroup_dump_controller: ::std::vec::Vec<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.freeze_cgroup) + pub freeze_cgroup: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.timeout) + pub timeout: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.tcp_skip_in_flight) + pub tcp_skip_in_flight: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.weak_sysctls) + pub weak_sysctls: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.lazy_pages) + pub lazy_pages: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.status_fd) + pub status_fd: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.orphan_pts_master) + pub orphan_pts_master: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.config_file) + pub config_file: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tcp_close) + pub tcp_close: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.lsm_profile) + pub lsm_profile: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tls_cacert) + pub tls_cacert: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tls_cacrl) + pub tls_cacrl: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tls_cert) + pub tls_cert: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tls_key) + pub tls_key: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.tls) + pub tls: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.tls_no_cn_verify) + pub tls_no_cn_verify: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.cgroup_yard) + pub cgroup_yard: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_opts.pre_dump_mode) + pub pre_dump_mode: ::std::option::Option<::protobuf::EnumOrUnknown>, + // @@protoc_insertion_point(field:criu_opts.pidfd_store_sk) + pub pidfd_store_sk: ::std::option::Option, + // @@protoc_insertion_point(field:criu_opts.lsm_mount_context) + pub lsm_mount_context: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:criu_opts.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_opts { + fn default() -> &'a Criu_opts { + ::default_instance() + } +} + +impl Criu_opts { + pub fn new() -> Criu_opts { + ::std::default::Default::default() + } + + // required int32 images_dir_fd = 1; + + pub fn images_dir_fd(&self) -> i32 { + self.images_dir_fd.unwrap_or(0) + } + + pub fn clear_images_dir_fd(&mut self) { + self.images_dir_fd = ::std::option::Option::None; + } + + pub fn has_images_dir_fd(&self) -> bool { + self.images_dir_fd.is_some() + } + + // Param is passed by value, moved + pub fn set_images_dir_fd(&mut self, v: i32) { + self.images_dir_fd = ::std::option::Option::Some(v); + } + + // optional int32 pid = 2; + + pub fn pid(&self) -> i32 { + self.pid.unwrap_or(0) + } + + pub fn clear_pid(&mut self) { + self.pid = ::std::option::Option::None; + } + + pub fn has_pid(&self) -> bool { + self.pid.is_some() + } + + // Param is passed by value, moved + pub fn set_pid(&mut self, v: i32) { + self.pid = ::std::option::Option::Some(v); + } + + // optional bool leave_running = 3; + + pub fn leave_running(&self) -> bool { + self.leave_running.unwrap_or(false) + } + + pub fn clear_leave_running(&mut self) { + self.leave_running = ::std::option::Option::None; + } + + pub fn has_leave_running(&self) -> bool { + self.leave_running.is_some() + } + + // Param is passed by value, moved + pub fn set_leave_running(&mut self, v: bool) { + self.leave_running = ::std::option::Option::Some(v); + } + + // optional bool ext_unix_sk = 4; + + pub fn ext_unix_sk(&self) -> bool { + self.ext_unix_sk.unwrap_or(false) + } + + pub fn clear_ext_unix_sk(&mut self) { + self.ext_unix_sk = ::std::option::Option::None; + } + + pub fn has_ext_unix_sk(&self) -> bool { + self.ext_unix_sk.is_some() + } + + // Param is passed by value, moved + pub fn set_ext_unix_sk(&mut self, v: bool) { + self.ext_unix_sk = ::std::option::Option::Some(v); + } + + // optional bool tcp_established = 5; + + pub fn tcp_established(&self) -> bool { + self.tcp_established.unwrap_or(false) + } + + pub fn clear_tcp_established(&mut self) { + self.tcp_established = ::std::option::Option::None; + } + + pub fn has_tcp_established(&self) -> bool { + self.tcp_established.is_some() + } + + // Param is passed by value, moved + pub fn set_tcp_established(&mut self, v: bool) { + self.tcp_established = ::std::option::Option::Some(v); + } + + // optional bool evasive_devices = 6; + + pub fn evasive_devices(&self) -> bool { + self.evasive_devices.unwrap_or(false) + } + + pub fn clear_evasive_devices(&mut self) { + self.evasive_devices = ::std::option::Option::None; + } + + pub fn has_evasive_devices(&self) -> bool { + self.evasive_devices.is_some() + } + + // Param is passed by value, moved + pub fn set_evasive_devices(&mut self, v: bool) { + self.evasive_devices = ::std::option::Option::Some(v); + } + + // optional bool shell_job = 7; + + pub fn shell_job(&self) -> bool { + self.shell_job.unwrap_or(false) + } + + pub fn clear_shell_job(&mut self) { + self.shell_job = ::std::option::Option::None; + } + + pub fn has_shell_job(&self) -> bool { + self.shell_job.is_some() + } + + // Param is passed by value, moved + pub fn set_shell_job(&mut self, v: bool) { + self.shell_job = ::std::option::Option::Some(v); + } + + // optional bool file_locks = 8; + + pub fn file_locks(&self) -> bool { + self.file_locks.unwrap_or(false) + } + + pub fn clear_file_locks(&mut self) { + self.file_locks = ::std::option::Option::None; + } + + pub fn has_file_locks(&self) -> bool { + self.file_locks.is_some() + } + + // Param is passed by value, moved + pub fn set_file_locks(&mut self, v: bool) { + self.file_locks = ::std::option::Option::Some(v); + } + + // optional int32 log_level = 9; + + pub fn log_level(&self) -> i32 { + self.log_level.unwrap_or(2i32) + } + + pub fn clear_log_level(&mut self) { + self.log_level = ::std::option::Option::None; + } + + pub fn has_log_level(&self) -> bool { + self.log_level.is_some() + } + + // Param is passed by value, moved + pub fn set_log_level(&mut self, v: i32) { + self.log_level = ::std::option::Option::Some(v); + } + + // optional string log_file = 10; + + pub fn log_file(&self) -> &str { + match self.log_file.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_log_file(&mut self) { + self.log_file = ::std::option::Option::None; + } + + pub fn has_log_file(&self) -> bool { + self.log_file.is_some() + } + + // Param is passed by value, moved + pub fn set_log_file(&mut self, v: ::std::string::String) { + self.log_file = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_log_file(&mut self) -> &mut ::std::string::String { + if self.log_file.is_none() { + self.log_file = ::std::option::Option::Some(::std::string::String::new()); + } + self.log_file.as_mut().unwrap() + } + + // Take field + pub fn take_log_file(&mut self) -> ::std::string::String { + self.log_file.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool notify_scripts = 12; + + pub fn notify_scripts(&self) -> bool { + self.notify_scripts.unwrap_or(false) + } + + pub fn clear_notify_scripts(&mut self) { + self.notify_scripts = ::std::option::Option::None; + } + + pub fn has_notify_scripts(&self) -> bool { + self.notify_scripts.is_some() + } + + // Param is passed by value, moved + pub fn set_notify_scripts(&mut self, v: bool) { + self.notify_scripts = ::std::option::Option::Some(v); + } + + // optional string root = 13; + + pub fn root(&self) -> &str { + match self.root.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_root(&mut self) { + self.root = ::std::option::Option::None; + } + + pub fn has_root(&self) -> bool { + self.root.is_some() + } + + // Param is passed by value, moved + pub fn set_root(&mut self, v: ::std::string::String) { + self.root = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_root(&mut self) -> &mut ::std::string::String { + if self.root.is_none() { + self.root = ::std::option::Option::Some(::std::string::String::new()); + } + self.root.as_mut().unwrap() + } + + // Take field + pub fn take_root(&mut self) -> ::std::string::String { + self.root.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string parent_img = 14; + + pub fn parent_img(&self) -> &str { + match self.parent_img.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_parent_img(&mut self) { + self.parent_img = ::std::option::Option::None; + } + + pub fn has_parent_img(&self) -> bool { + self.parent_img.is_some() + } + + // Param is passed by value, moved + pub fn set_parent_img(&mut self, v: ::std::string::String) { + self.parent_img = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_parent_img(&mut self) -> &mut ::std::string::String { + if self.parent_img.is_none() { + self.parent_img = ::std::option::Option::Some(::std::string::String::new()); + } + self.parent_img.as_mut().unwrap() + } + + // Take field + pub fn take_parent_img(&mut self) -> ::std::string::String { + self.parent_img.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool track_mem = 15; + + pub fn track_mem(&self) -> bool { + self.track_mem.unwrap_or(false) + } + + pub fn clear_track_mem(&mut self) { + self.track_mem = ::std::option::Option::None; + } + + pub fn has_track_mem(&self) -> bool { + self.track_mem.is_some() + } + + // Param is passed by value, moved + pub fn set_track_mem(&mut self, v: bool) { + self.track_mem = ::std::option::Option::Some(v); + } + + // optional bool auto_dedup = 16; + + pub fn auto_dedup(&self) -> bool { + self.auto_dedup.unwrap_or(false) + } + + pub fn clear_auto_dedup(&mut self) { + self.auto_dedup = ::std::option::Option::None; + } + + pub fn has_auto_dedup(&self) -> bool { + self.auto_dedup.is_some() + } + + // Param is passed by value, moved + pub fn set_auto_dedup(&mut self, v: bool) { + self.auto_dedup = ::std::option::Option::Some(v); + } + + // optional int32 work_dir_fd = 17; + + pub fn work_dir_fd(&self) -> i32 { + self.work_dir_fd.unwrap_or(0) + } + + pub fn clear_work_dir_fd(&mut self) { + self.work_dir_fd = ::std::option::Option::None; + } + + pub fn has_work_dir_fd(&self) -> bool { + self.work_dir_fd.is_some() + } + + // Param is passed by value, moved + pub fn set_work_dir_fd(&mut self, v: i32) { + self.work_dir_fd = ::std::option::Option::Some(v); + } + + // optional bool link_remap = 18; + + pub fn link_remap(&self) -> bool { + self.link_remap.unwrap_or(false) + } + + pub fn clear_link_remap(&mut self) { + self.link_remap = ::std::option::Option::None; + } + + pub fn has_link_remap(&self) -> bool { + self.link_remap.is_some() + } + + // Param is passed by value, moved + pub fn set_link_remap(&mut self, v: bool) { + self.link_remap = ::std::option::Option::Some(v); + } + + // optional uint32 cpu_cap = 20; + + pub fn cpu_cap(&self) -> u32 { + self.cpu_cap.unwrap_or(4294967295u32) + } + + pub fn clear_cpu_cap(&mut self) { + self.cpu_cap = ::std::option::Option::None; + } + + pub fn has_cpu_cap(&self) -> bool { + self.cpu_cap.is_some() + } + + // Param is passed by value, moved + pub fn set_cpu_cap(&mut self, v: u32) { + self.cpu_cap = ::std::option::Option::Some(v); + } + + // optional bool force_irmap = 21; + + pub fn force_irmap(&self) -> bool { + self.force_irmap.unwrap_or(false) + } + + pub fn clear_force_irmap(&mut self) { + self.force_irmap = ::std::option::Option::None; + } + + pub fn has_force_irmap(&self) -> bool { + self.force_irmap.is_some() + } + + // Param is passed by value, moved + pub fn set_force_irmap(&mut self, v: bool) { + self.force_irmap = ::std::option::Option::Some(v); + } + + // optional bool manage_cgroups = 24; + + pub fn manage_cgroups(&self) -> bool { + self.manage_cgroups.unwrap_or(false) + } + + pub fn clear_manage_cgroups(&mut self) { + self.manage_cgroups = ::std::option::Option::None; + } + + pub fn has_manage_cgroups(&self) -> bool { + self.manage_cgroups.is_some() + } + + // Param is passed by value, moved + pub fn set_manage_cgroups(&mut self, v: bool) { + self.manage_cgroups = ::std::option::Option::Some(v); + } + + // optional bool rst_sibling = 26; + + pub fn rst_sibling(&self) -> bool { + self.rst_sibling.unwrap_or(false) + } + + pub fn clear_rst_sibling(&mut self) { + self.rst_sibling = ::std::option::Option::None; + } + + pub fn has_rst_sibling(&self) -> bool { + self.rst_sibling.is_some() + } + + // Param is passed by value, moved + pub fn set_rst_sibling(&mut self, v: bool) { + self.rst_sibling = ::std::option::Option::Some(v); + } + + // optional bool auto_ext_mnt = 28; + + pub fn auto_ext_mnt(&self) -> bool { + self.auto_ext_mnt.unwrap_or(false) + } + + pub fn clear_auto_ext_mnt(&mut self) { + self.auto_ext_mnt = ::std::option::Option::None; + } + + pub fn has_auto_ext_mnt(&self) -> bool { + self.auto_ext_mnt.is_some() + } + + // Param is passed by value, moved + pub fn set_auto_ext_mnt(&mut self, v: bool) { + self.auto_ext_mnt = ::std::option::Option::Some(v); + } + + // optional bool ext_sharing = 29; + + pub fn ext_sharing(&self) -> bool { + self.ext_sharing.unwrap_or(false) + } + + pub fn clear_ext_sharing(&mut self) { + self.ext_sharing = ::std::option::Option::None; + } + + pub fn has_ext_sharing(&self) -> bool { + self.ext_sharing.is_some() + } + + // Param is passed by value, moved + pub fn set_ext_sharing(&mut self, v: bool) { + self.ext_sharing = ::std::option::Option::Some(v); + } + + // optional bool ext_masters = 30; + + pub fn ext_masters(&self) -> bool { + self.ext_masters.unwrap_or(false) + } + + pub fn clear_ext_masters(&mut self) { + self.ext_masters = ::std::option::Option::None; + } + + pub fn has_ext_masters(&self) -> bool { + self.ext_masters.is_some() + } + + // Param is passed by value, moved + pub fn set_ext_masters(&mut self, v: bool) { + self.ext_masters = ::std::option::Option::Some(v); + } + + // optional .criu_cg_mode manage_cgroups_mode = 34; + + pub fn manage_cgroups_mode(&self) -> Criu_cg_mode { + match self.manage_cgroups_mode { + Some(e) => e.enum_value_or(Criu_cg_mode::IGNORE), + None => Criu_cg_mode::IGNORE, + } + } + + pub fn clear_manage_cgroups_mode(&mut self) { + self.manage_cgroups_mode = ::std::option::Option::None; + } + + pub fn has_manage_cgroups_mode(&self) -> bool { + self.manage_cgroups_mode.is_some() + } + + // Param is passed by value, moved + pub fn set_manage_cgroups_mode(&mut self, v: Criu_cg_mode) { + self.manage_cgroups_mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); + } + + // optional uint32 ghost_limit = 35; + + pub fn ghost_limit(&self) -> u32 { + self.ghost_limit.unwrap_or(1048576u32) + } + + pub fn clear_ghost_limit(&mut self) { + self.ghost_limit = ::std::option::Option::None; + } + + pub fn has_ghost_limit(&self) -> bool { + self.ghost_limit.is_some() + } + + // Param is passed by value, moved + pub fn set_ghost_limit(&mut self, v: u32) { + self.ghost_limit = ::std::option::Option::Some(v); + } + + // optional uint32 empty_ns = 38; + + pub fn empty_ns(&self) -> u32 { + self.empty_ns.unwrap_or(0) + } + + pub fn clear_empty_ns(&mut self) { + self.empty_ns = ::std::option::Option::None; + } + + pub fn has_empty_ns(&self) -> bool { + self.empty_ns.is_some() + } + + // Param is passed by value, moved + pub fn set_empty_ns(&mut self, v: u32) { + self.empty_ns = ::std::option::Option::Some(v); + } + + // optional string cgroup_props = 41; + + pub fn cgroup_props(&self) -> &str { + match self.cgroup_props.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_cgroup_props(&mut self) { + self.cgroup_props = ::std::option::Option::None; + } + + pub fn has_cgroup_props(&self) -> bool { + self.cgroup_props.is_some() + } + + // Param is passed by value, moved + pub fn set_cgroup_props(&mut self, v: ::std::string::String) { + self.cgroup_props = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cgroup_props(&mut self) -> &mut ::std::string::String { + if self.cgroup_props.is_none() { + self.cgroup_props = ::std::option::Option::Some(::std::string::String::new()); + } + self.cgroup_props.as_mut().unwrap() + } + + // Take field + pub fn take_cgroup_props(&mut self) -> ::std::string::String { + self.cgroup_props.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string cgroup_props_file = 42; + + pub fn cgroup_props_file(&self) -> &str { + match self.cgroup_props_file.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_cgroup_props_file(&mut self) { + self.cgroup_props_file = ::std::option::Option::None; + } + + pub fn has_cgroup_props_file(&self) -> bool { + self.cgroup_props_file.is_some() + } + + // Param is passed by value, moved + pub fn set_cgroup_props_file(&mut self, v: ::std::string::String) { + self.cgroup_props_file = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cgroup_props_file(&mut self) -> &mut ::std::string::String { + if self.cgroup_props_file.is_none() { + self.cgroup_props_file = ::std::option::Option::Some(::std::string::String::new()); + } + self.cgroup_props_file.as_mut().unwrap() + } + + // Take field + pub fn take_cgroup_props_file(&mut self) -> ::std::string::String { + self.cgroup_props_file.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string freeze_cgroup = 44; + + pub fn freeze_cgroup(&self) -> &str { + match self.freeze_cgroup.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_freeze_cgroup(&mut self) { + self.freeze_cgroup = ::std::option::Option::None; + } + + pub fn has_freeze_cgroup(&self) -> bool { + self.freeze_cgroup.is_some() + } + + // Param is passed by value, moved + pub fn set_freeze_cgroup(&mut self, v: ::std::string::String) { + self.freeze_cgroup = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_freeze_cgroup(&mut self) -> &mut ::std::string::String { + if self.freeze_cgroup.is_none() { + self.freeze_cgroup = ::std::option::Option::Some(::std::string::String::new()); + } + self.freeze_cgroup.as_mut().unwrap() + } + + // Take field + pub fn take_freeze_cgroup(&mut self) -> ::std::string::String { + self.freeze_cgroup.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional uint32 timeout = 45; + + pub fn timeout(&self) -> u32 { + self.timeout.unwrap_or(0) + } + + pub fn clear_timeout(&mut self) { + self.timeout = ::std::option::Option::None; + } + + pub fn has_timeout(&self) -> bool { + self.timeout.is_some() + } + + // Param is passed by value, moved + pub fn set_timeout(&mut self, v: u32) { + self.timeout = ::std::option::Option::Some(v); + } + + // optional bool tcp_skip_in_flight = 46; + + pub fn tcp_skip_in_flight(&self) -> bool { + self.tcp_skip_in_flight.unwrap_or(false) + } + + pub fn clear_tcp_skip_in_flight(&mut self) { + self.tcp_skip_in_flight = ::std::option::Option::None; + } + + pub fn has_tcp_skip_in_flight(&self) -> bool { + self.tcp_skip_in_flight.is_some() + } + + // Param is passed by value, moved + pub fn set_tcp_skip_in_flight(&mut self, v: bool) { + self.tcp_skip_in_flight = ::std::option::Option::Some(v); + } + + // optional bool weak_sysctls = 47; + + pub fn weak_sysctls(&self) -> bool { + self.weak_sysctls.unwrap_or(false) + } + + pub fn clear_weak_sysctls(&mut self) { + self.weak_sysctls = ::std::option::Option::None; + } + + pub fn has_weak_sysctls(&self) -> bool { + self.weak_sysctls.is_some() + } + + // Param is passed by value, moved + pub fn set_weak_sysctls(&mut self, v: bool) { + self.weak_sysctls = ::std::option::Option::Some(v); + } + + // optional bool lazy_pages = 48; + + pub fn lazy_pages(&self) -> bool { + self.lazy_pages.unwrap_or(false) + } + + pub fn clear_lazy_pages(&mut self) { + self.lazy_pages = ::std::option::Option::None; + } + + pub fn has_lazy_pages(&self) -> bool { + self.lazy_pages.is_some() + } + + // Param is passed by value, moved + pub fn set_lazy_pages(&mut self, v: bool) { + self.lazy_pages = ::std::option::Option::Some(v); + } + + // optional int32 status_fd = 49; + + pub fn status_fd(&self) -> i32 { + self.status_fd.unwrap_or(0) + } + + pub fn clear_status_fd(&mut self) { + self.status_fd = ::std::option::Option::None; + } + + pub fn has_status_fd(&self) -> bool { + self.status_fd.is_some() + } + + // Param is passed by value, moved + pub fn set_status_fd(&mut self, v: i32) { + self.status_fd = ::std::option::Option::Some(v); + } + + // optional bool orphan_pts_master = 50; + + pub fn orphan_pts_master(&self) -> bool { + self.orphan_pts_master.unwrap_or(false) + } + + pub fn clear_orphan_pts_master(&mut self) { + self.orphan_pts_master = ::std::option::Option::None; + } + + pub fn has_orphan_pts_master(&self) -> bool { + self.orphan_pts_master.is_some() + } + + // Param is passed by value, moved + pub fn set_orphan_pts_master(&mut self, v: bool) { + self.orphan_pts_master = ::std::option::Option::Some(v); + } + + // optional string config_file = 51; + + pub fn config_file(&self) -> &str { + match self.config_file.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_config_file(&mut self) { + self.config_file = ::std::option::Option::None; + } + + pub fn has_config_file(&self) -> bool { + self.config_file.is_some() + } + + // Param is passed by value, moved + pub fn set_config_file(&mut self, v: ::std::string::String) { + self.config_file = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_config_file(&mut self) -> &mut ::std::string::String { + if self.config_file.is_none() { + self.config_file = ::std::option::Option::Some(::std::string::String::new()); + } + self.config_file.as_mut().unwrap() + } + + // Take field + pub fn take_config_file(&mut self) -> ::std::string::String { + self.config_file.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool tcp_close = 52; + + pub fn tcp_close(&self) -> bool { + self.tcp_close.unwrap_or(false) + } + + pub fn clear_tcp_close(&mut self) { + self.tcp_close = ::std::option::Option::None; + } + + pub fn has_tcp_close(&self) -> bool { + self.tcp_close.is_some() + } + + // Param is passed by value, moved + pub fn set_tcp_close(&mut self, v: bool) { + self.tcp_close = ::std::option::Option::Some(v); + } + + // optional string lsm_profile = 53; + + pub fn lsm_profile(&self) -> &str { + match self.lsm_profile.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_lsm_profile(&mut self) { + self.lsm_profile = ::std::option::Option::None; + } + + pub fn has_lsm_profile(&self) -> bool { + self.lsm_profile.is_some() + } + + // Param is passed by value, moved + pub fn set_lsm_profile(&mut self, v: ::std::string::String) { + self.lsm_profile = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_lsm_profile(&mut self) -> &mut ::std::string::String { + if self.lsm_profile.is_none() { + self.lsm_profile = ::std::option::Option::Some(::std::string::String::new()); + } + self.lsm_profile.as_mut().unwrap() + } + + // Take field + pub fn take_lsm_profile(&mut self) -> ::std::string::String { + self.lsm_profile.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string tls_cacert = 54; + + pub fn tls_cacert(&self) -> &str { + match self.tls_cacert.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_tls_cacert(&mut self) { + self.tls_cacert = ::std::option::Option::None; + } + + pub fn has_tls_cacert(&self) -> bool { + self.tls_cacert.is_some() + } + + // Param is passed by value, moved + pub fn set_tls_cacert(&mut self, v: ::std::string::String) { + self.tls_cacert = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_tls_cacert(&mut self) -> &mut ::std::string::String { + if self.tls_cacert.is_none() { + self.tls_cacert = ::std::option::Option::Some(::std::string::String::new()); + } + self.tls_cacert.as_mut().unwrap() + } + + // Take field + pub fn take_tls_cacert(&mut self) -> ::std::string::String { + self.tls_cacert.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string tls_cacrl = 55; + + pub fn tls_cacrl(&self) -> &str { + match self.tls_cacrl.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_tls_cacrl(&mut self) { + self.tls_cacrl = ::std::option::Option::None; + } + + pub fn has_tls_cacrl(&self) -> bool { + self.tls_cacrl.is_some() + } + + // Param is passed by value, moved + pub fn set_tls_cacrl(&mut self, v: ::std::string::String) { + self.tls_cacrl = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_tls_cacrl(&mut self) -> &mut ::std::string::String { + if self.tls_cacrl.is_none() { + self.tls_cacrl = ::std::option::Option::Some(::std::string::String::new()); + } + self.tls_cacrl.as_mut().unwrap() + } + + // Take field + pub fn take_tls_cacrl(&mut self) -> ::std::string::String { + self.tls_cacrl.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string tls_cert = 56; + + pub fn tls_cert(&self) -> &str { + match self.tls_cert.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_tls_cert(&mut self) { + self.tls_cert = ::std::option::Option::None; + } + + pub fn has_tls_cert(&self) -> bool { + self.tls_cert.is_some() + } + + // Param is passed by value, moved + pub fn set_tls_cert(&mut self, v: ::std::string::String) { + self.tls_cert = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_tls_cert(&mut self) -> &mut ::std::string::String { + if self.tls_cert.is_none() { + self.tls_cert = ::std::option::Option::Some(::std::string::String::new()); + } + self.tls_cert.as_mut().unwrap() + } + + // Take field + pub fn take_tls_cert(&mut self) -> ::std::string::String { + self.tls_cert.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional string tls_key = 57; + + pub fn tls_key(&self) -> &str { + match self.tls_key.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_tls_key(&mut self) { + self.tls_key = ::std::option::Option::None; + } + + pub fn has_tls_key(&self) -> bool { + self.tls_key.is_some() + } + + // Param is passed by value, moved + pub fn set_tls_key(&mut self, v: ::std::string::String) { + self.tls_key = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_tls_key(&mut self) -> &mut ::std::string::String { + if self.tls_key.is_none() { + self.tls_key = ::std::option::Option::Some(::std::string::String::new()); + } + self.tls_key.as_mut().unwrap() + } + + // Take field + pub fn take_tls_key(&mut self) -> ::std::string::String { + self.tls_key.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional bool tls = 58; + + pub fn tls(&self) -> bool { + self.tls.unwrap_or(false) + } + + pub fn clear_tls(&mut self) { + self.tls = ::std::option::Option::None; + } + + pub fn has_tls(&self) -> bool { + self.tls.is_some() + } + + // Param is passed by value, moved + pub fn set_tls(&mut self, v: bool) { + self.tls = ::std::option::Option::Some(v); + } + + // optional bool tls_no_cn_verify = 59; + + pub fn tls_no_cn_verify(&self) -> bool { + self.tls_no_cn_verify.unwrap_or(false) + } + + pub fn clear_tls_no_cn_verify(&mut self) { + self.tls_no_cn_verify = ::std::option::Option::None; + } + + pub fn has_tls_no_cn_verify(&self) -> bool { + self.tls_no_cn_verify.is_some() + } + + // Param is passed by value, moved + pub fn set_tls_no_cn_verify(&mut self, v: bool) { + self.tls_no_cn_verify = ::std::option::Option::Some(v); + } + + // optional string cgroup_yard = 60; + + pub fn cgroup_yard(&self) -> &str { + match self.cgroup_yard.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_cgroup_yard(&mut self) { + self.cgroup_yard = ::std::option::Option::None; + } + + pub fn has_cgroup_yard(&self) -> bool { + self.cgroup_yard.is_some() + } + + // Param is passed by value, moved + pub fn set_cgroup_yard(&mut self, v: ::std::string::String) { + self.cgroup_yard = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cgroup_yard(&mut self) -> &mut ::std::string::String { + if self.cgroup_yard.is_none() { + self.cgroup_yard = ::std::option::Option::Some(::std::string::String::new()); + } + self.cgroup_yard.as_mut().unwrap() + } + + // Take field + pub fn take_cgroup_yard(&mut self) -> ::std::string::String { + self.cgroup_yard.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional .criu_pre_dump_mode pre_dump_mode = 61; + + pub fn pre_dump_mode(&self) -> Criu_pre_dump_mode { + match self.pre_dump_mode { + Some(e) => e.enum_value_or(Criu_pre_dump_mode::SPLICE), + None => Criu_pre_dump_mode::SPLICE, + } + } + + pub fn clear_pre_dump_mode(&mut self) { + self.pre_dump_mode = ::std::option::Option::None; + } + + pub fn has_pre_dump_mode(&self) -> bool { + self.pre_dump_mode.is_some() + } + + // Param is passed by value, moved + pub fn set_pre_dump_mode(&mut self, v: Criu_pre_dump_mode) { + self.pre_dump_mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); + } + + // optional int32 pidfd_store_sk = 62; + + pub fn pidfd_store_sk(&self) -> i32 { + self.pidfd_store_sk.unwrap_or(0) + } + + pub fn clear_pidfd_store_sk(&mut self) { + self.pidfd_store_sk = ::std::option::Option::None; + } + + pub fn has_pidfd_store_sk(&self) -> bool { + self.pidfd_store_sk.is_some() + } + + // Param is passed by value, moved + pub fn set_pidfd_store_sk(&mut self, v: i32) { + self.pidfd_store_sk = ::std::option::Option::Some(v); + } + + // optional string lsm_mount_context = 63; + + pub fn lsm_mount_context(&self) -> &str { + match self.lsm_mount_context.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_lsm_mount_context(&mut self) { + self.lsm_mount_context = ::std::option::Option::None; + } + + pub fn has_lsm_mount_context(&self) -> bool { + self.lsm_mount_context.is_some() + } + + // Param is passed by value, moved + pub fn set_lsm_mount_context(&mut self, v: ::std::string::String) { + self.lsm_mount_context = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_lsm_mount_context(&mut self) -> &mut ::std::string::String { + if self.lsm_mount_context.is_none() { + self.lsm_mount_context = ::std::option::Option::Some(::std::string::String::new()); + } + self.lsm_mount_context.as_mut().unwrap() + } + + // Take field + pub fn take_lsm_mount_context(&mut self) -> ::std::string::String { + self.lsm_mount_context.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(62); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "images_dir_fd", + |m: &Criu_opts| { &m.images_dir_fd }, + |m: &mut Criu_opts| { &mut m.images_dir_fd }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pid", + |m: &Criu_opts| { &m.pid }, + |m: &mut Criu_opts| { &mut m.pid }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "leave_running", + |m: &Criu_opts| { &m.leave_running }, + |m: &mut Criu_opts| { &mut m.leave_running }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ext_unix_sk", + |m: &Criu_opts| { &m.ext_unix_sk }, + |m: &mut Criu_opts| { &mut m.ext_unix_sk }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tcp_established", + |m: &Criu_opts| { &m.tcp_established }, + |m: &mut Criu_opts| { &mut m.tcp_established }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "evasive_devices", + |m: &Criu_opts| { &m.evasive_devices }, + |m: &mut Criu_opts| { &mut m.evasive_devices }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "shell_job", + |m: &Criu_opts| { &m.shell_job }, + |m: &mut Criu_opts| { &mut m.shell_job }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "file_locks", + |m: &Criu_opts| { &m.file_locks }, + |m: &mut Criu_opts| { &mut m.file_locks }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "log_level", + |m: &Criu_opts| { &m.log_level }, + |m: &mut Criu_opts| { &mut m.log_level }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "log_file", + |m: &Criu_opts| { &m.log_file }, + |m: &mut Criu_opts| { &mut m.log_file }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_page_server_info>( + "ps", + |m: &Criu_opts| { &m.ps }, + |m: &mut Criu_opts| { &mut m.ps }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "notify_scripts", + |m: &Criu_opts| { &m.notify_scripts }, + |m: &mut Criu_opts| { &mut m.notify_scripts }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "root", + |m: &Criu_opts| { &m.root }, + |m: &mut Criu_opts| { &mut m.root }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "parent_img", + |m: &Criu_opts| { &m.parent_img }, + |m: &mut Criu_opts| { &mut m.parent_img }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "track_mem", + |m: &Criu_opts| { &m.track_mem }, + |m: &mut Criu_opts| { &mut m.track_mem }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "auto_dedup", + |m: &Criu_opts| { &m.auto_dedup }, + |m: &mut Criu_opts| { &mut m.auto_dedup }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "work_dir_fd", + |m: &Criu_opts| { &m.work_dir_fd }, + |m: &mut Criu_opts| { &mut m.work_dir_fd }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "link_remap", + |m: &Criu_opts| { &m.link_remap }, + |m: &mut Criu_opts| { &mut m.link_remap }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "veths", + |m: &Criu_opts| { &m.veths }, + |m: &mut Criu_opts| { &mut m.veths }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cpu_cap", + |m: &Criu_opts| { &m.cpu_cap }, + |m: &mut Criu_opts| { &mut m.cpu_cap }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "force_irmap", + |m: &Criu_opts| { &m.force_irmap }, + |m: &mut Criu_opts| { &mut m.force_irmap }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "exec_cmd", + |m: &Criu_opts| { &m.exec_cmd }, + |m: &mut Criu_opts| { &mut m.exec_cmd }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "ext_mnt", + |m: &Criu_opts| { &m.ext_mnt }, + |m: &mut Criu_opts| { &mut m.ext_mnt }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "manage_cgroups", + |m: &Criu_opts| { &m.manage_cgroups }, + |m: &mut Criu_opts| { &mut m.manage_cgroups }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "cg_root", + |m: &Criu_opts| { &m.cg_root }, + |m: &mut Criu_opts| { &mut m.cg_root }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "rst_sibling", + |m: &Criu_opts| { &m.rst_sibling }, + |m: &mut Criu_opts| { &mut m.rst_sibling }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "inherit_fd", + |m: &Criu_opts| { &m.inherit_fd }, + |m: &mut Criu_opts| { &mut m.inherit_fd }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "auto_ext_mnt", + |m: &Criu_opts| { &m.auto_ext_mnt }, + |m: &mut Criu_opts| { &mut m.auto_ext_mnt }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ext_sharing", + |m: &Criu_opts| { &m.ext_sharing }, + |m: &mut Criu_opts| { &mut m.ext_sharing }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ext_masters", + |m: &Criu_opts| { &m.ext_masters }, + |m: &mut Criu_opts| { &mut m.ext_masters }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "skip_mnt", + |m: &Criu_opts| { &m.skip_mnt }, + |m: &mut Criu_opts| { &mut m.skip_mnt }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "enable_fs", + |m: &Criu_opts| { &m.enable_fs }, + |m: &mut Criu_opts| { &mut m.enable_fs }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "unix_sk_ino", + |m: &Criu_opts| { &m.unix_sk_ino }, + |m: &mut Criu_opts| { &mut m.unix_sk_ino }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "manage_cgroups_mode", + |m: &Criu_opts| { &m.manage_cgroups_mode }, + |m: &mut Criu_opts| { &mut m.manage_cgroups_mode }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "ghost_limit", + |m: &Criu_opts| { &m.ghost_limit }, + |m: &mut Criu_opts| { &mut m.ghost_limit }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "irmap_scan_paths", + |m: &Criu_opts| { &m.irmap_scan_paths }, + |m: &mut Criu_opts| { &mut m.irmap_scan_paths }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "external", + |m: &Criu_opts| { &m.external }, + |m: &mut Criu_opts| { &mut m.external }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "empty_ns", + |m: &Criu_opts| { &m.empty_ns }, + |m: &mut Criu_opts| { &mut m.empty_ns }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "join_ns", + |m: &Criu_opts| { &m.join_ns }, + |m: &mut Criu_opts| { &mut m.join_ns }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cgroup_props", + |m: &Criu_opts| { &m.cgroup_props }, + |m: &mut Criu_opts| { &mut m.cgroup_props }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cgroup_props_file", + |m: &Criu_opts| { &m.cgroup_props_file }, + |m: &mut Criu_opts| { &mut m.cgroup_props_file }, + )); + fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>( + "cgroup_dump_controller", + |m: &Criu_opts| { &m.cgroup_dump_controller }, + |m: &mut Criu_opts| { &mut m.cgroup_dump_controller }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "freeze_cgroup", + |m: &Criu_opts| { &m.freeze_cgroup }, + |m: &mut Criu_opts| { &mut m.freeze_cgroup }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "timeout", + |m: &Criu_opts| { &m.timeout }, + |m: &mut Criu_opts| { &mut m.timeout }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tcp_skip_in_flight", + |m: &Criu_opts| { &m.tcp_skip_in_flight }, + |m: &mut Criu_opts| { &mut m.tcp_skip_in_flight }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "weak_sysctls", + |m: &Criu_opts| { &m.weak_sysctls }, + |m: &mut Criu_opts| { &mut m.weak_sysctls }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "lazy_pages", + |m: &Criu_opts| { &m.lazy_pages }, + |m: &mut Criu_opts| { &mut m.lazy_pages }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "status_fd", + |m: &Criu_opts| { &m.status_fd }, + |m: &mut Criu_opts| { &mut m.status_fd }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "orphan_pts_master", + |m: &Criu_opts| { &m.orphan_pts_master }, + |m: &mut Criu_opts| { &mut m.orphan_pts_master }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "config_file", + |m: &Criu_opts| { &m.config_file }, + |m: &mut Criu_opts| { &mut m.config_file }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tcp_close", + |m: &Criu_opts| { &m.tcp_close }, + |m: &mut Criu_opts| { &mut m.tcp_close }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "lsm_profile", + |m: &Criu_opts| { &m.lsm_profile }, + |m: &mut Criu_opts| { &mut m.lsm_profile }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls_cacert", + |m: &Criu_opts| { &m.tls_cacert }, + |m: &mut Criu_opts| { &mut m.tls_cacert }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls_cacrl", + |m: &Criu_opts| { &m.tls_cacrl }, + |m: &mut Criu_opts| { &mut m.tls_cacrl }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls_cert", + |m: &Criu_opts| { &m.tls_cert }, + |m: &mut Criu_opts| { &mut m.tls_cert }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls_key", + |m: &Criu_opts| { &m.tls_key }, + |m: &mut Criu_opts| { &mut m.tls_key }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls", + |m: &Criu_opts| { &m.tls }, + |m: &mut Criu_opts| { &mut m.tls }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "tls_no_cn_verify", + |m: &Criu_opts| { &m.tls_no_cn_verify }, + |m: &mut Criu_opts| { &mut m.tls_no_cn_verify }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cgroup_yard", + |m: &Criu_opts| { &m.cgroup_yard }, + |m: &mut Criu_opts| { &mut m.cgroup_yard }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pre_dump_mode", + |m: &Criu_opts| { &m.pre_dump_mode }, + |m: &mut Criu_opts| { &mut m.pre_dump_mode }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pidfd_store_sk", + |m: &Criu_opts| { &m.pidfd_store_sk }, + |m: &mut Criu_opts| { &mut m.pidfd_store_sk }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "lsm_mount_context", + |m: &Criu_opts| { &m.lsm_mount_context }, + |m: &mut Criu_opts| { &mut m.lsm_mount_context }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_opts", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_opts { + const NAME: &'static str = "criu_opts"; + + fn is_initialized(&self) -> bool { + if self.images_dir_fd.is_none() { + return false; + } + for v in &self.ps { + if !v.is_initialized() { + return false; + } + }; + for v in &self.veths { + if !v.is_initialized() { + return false; + } + }; + for v in &self.ext_mnt { + if !v.is_initialized() { + return false; + } + }; + for v in &self.cg_root { + if !v.is_initialized() { + return false; + } + }; + for v in &self.inherit_fd { + if !v.is_initialized() { + return false; + } + }; + for v in &self.unix_sk_ino { + if !v.is_initialized() { + return false; + } + }; + for v in &self.join_ns { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.images_dir_fd = ::std::option::Option::Some(is.read_int32()?); + }, + 16 => { + self.pid = ::std::option::Option::Some(is.read_int32()?); + }, + 24 => { + self.leave_running = ::std::option::Option::Some(is.read_bool()?); + }, + 32 => { + self.ext_unix_sk = ::std::option::Option::Some(is.read_bool()?); + }, + 40 => { + self.tcp_established = ::std::option::Option::Some(is.read_bool()?); + }, + 48 => { + self.evasive_devices = ::std::option::Option::Some(is.read_bool()?); + }, + 56 => { + self.shell_job = ::std::option::Option::Some(is.read_bool()?); + }, + 64 => { + self.file_locks = ::std::option::Option::Some(is.read_bool()?); + }, + 72 => { + self.log_level = ::std::option::Option::Some(is.read_int32()?); + }, + 82 => { + self.log_file = ::std::option::Option::Some(is.read_string()?); + }, + 90 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.ps)?; + }, + 96 => { + self.notify_scripts = ::std::option::Option::Some(is.read_bool()?); + }, + 106 => { + self.root = ::std::option::Option::Some(is.read_string()?); + }, + 114 => { + self.parent_img = ::std::option::Option::Some(is.read_string()?); + }, + 120 => { + self.track_mem = ::std::option::Option::Some(is.read_bool()?); + }, + 128 => { + self.auto_dedup = ::std::option::Option::Some(is.read_bool()?); + }, + 136 => { + self.work_dir_fd = ::std::option::Option::Some(is.read_int32()?); + }, + 144 => { + self.link_remap = ::std::option::Option::Some(is.read_bool()?); + }, + 154 => { + self.veths.push(is.read_message()?); + }, + 160 => { + self.cpu_cap = ::std::option::Option::Some(is.read_uint32()?); + }, + 168 => { + self.force_irmap = ::std::option::Option::Some(is.read_bool()?); + }, + 178 => { + self.exec_cmd.push(is.read_string()?); + }, + 186 => { + self.ext_mnt.push(is.read_message()?); + }, + 192 => { + self.manage_cgroups = ::std::option::Option::Some(is.read_bool()?); + }, + 202 => { + self.cg_root.push(is.read_message()?); + }, + 208 => { + self.rst_sibling = ::std::option::Option::Some(is.read_bool()?); + }, + 218 => { + self.inherit_fd.push(is.read_message()?); + }, + 224 => { + self.auto_ext_mnt = ::std::option::Option::Some(is.read_bool()?); + }, + 232 => { + self.ext_sharing = ::std::option::Option::Some(is.read_bool()?); + }, + 240 => { + self.ext_masters = ::std::option::Option::Some(is.read_bool()?); + }, + 250 => { + self.skip_mnt.push(is.read_string()?); + }, + 258 => { + self.enable_fs.push(is.read_string()?); + }, + 266 => { + self.unix_sk_ino.push(is.read_message()?); + }, + 272 => { + self.manage_cgroups_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?); + }, + 280 => { + self.ghost_limit = ::std::option::Option::Some(is.read_uint32()?); + }, + 290 => { + self.irmap_scan_paths.push(is.read_string()?); + }, + 298 => { + self.external.push(is.read_string()?); + }, + 304 => { + self.empty_ns = ::std::option::Option::Some(is.read_uint32()?); + }, + 314 => { + self.join_ns.push(is.read_message()?); + }, + 330 => { + self.cgroup_props = ::std::option::Option::Some(is.read_string()?); + }, + 338 => { + self.cgroup_props_file = ::std::option::Option::Some(is.read_string()?); + }, + 346 => { + self.cgroup_dump_controller.push(is.read_string()?); + }, + 354 => { + self.freeze_cgroup = ::std::option::Option::Some(is.read_string()?); + }, + 360 => { + self.timeout = ::std::option::Option::Some(is.read_uint32()?); + }, + 368 => { + self.tcp_skip_in_flight = ::std::option::Option::Some(is.read_bool()?); + }, + 376 => { + self.weak_sysctls = ::std::option::Option::Some(is.read_bool()?); + }, + 384 => { + self.lazy_pages = ::std::option::Option::Some(is.read_bool()?); + }, + 392 => { + self.status_fd = ::std::option::Option::Some(is.read_int32()?); + }, + 400 => { + self.orphan_pts_master = ::std::option::Option::Some(is.read_bool()?); + }, + 410 => { + self.config_file = ::std::option::Option::Some(is.read_string()?); + }, + 416 => { + self.tcp_close = ::std::option::Option::Some(is.read_bool()?); + }, + 426 => { + self.lsm_profile = ::std::option::Option::Some(is.read_string()?); + }, + 434 => { + self.tls_cacert = ::std::option::Option::Some(is.read_string()?); + }, + 442 => { + self.tls_cacrl = ::std::option::Option::Some(is.read_string()?); + }, + 450 => { + self.tls_cert = ::std::option::Option::Some(is.read_string()?); + }, + 458 => { + self.tls_key = ::std::option::Option::Some(is.read_string()?); + }, + 464 => { + self.tls = ::std::option::Option::Some(is.read_bool()?); + }, + 472 => { + self.tls_no_cn_verify = ::std::option::Option::Some(is.read_bool()?); + }, + 482 => { + self.cgroup_yard = ::std::option::Option::Some(is.read_string()?); + }, + 488 => { + self.pre_dump_mode = ::std::option::Option::Some(is.read_enum_or_unknown()?); + }, + 496 => { + self.pidfd_store_sk = ::std::option::Option::Some(is.read_int32()?); + }, + 506 => { + self.lsm_mount_context = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.images_dir_fd { + my_size += ::protobuf::rt::int32_size(1, v); + } + if let Some(v) = self.pid { + my_size += ::protobuf::rt::int32_size(2, v); + } + if let Some(v) = self.leave_running { + my_size += 1 + 1; + } + if let Some(v) = self.ext_unix_sk { + my_size += 1 + 1; + } + if let Some(v) = self.tcp_established { + my_size += 1 + 1; + } + if let Some(v) = self.evasive_devices { + my_size += 1 + 1; + } + if let Some(v) = self.shell_job { + my_size += 1 + 1; + } + if let Some(v) = self.file_locks { + my_size += 1 + 1; + } + if let Some(v) = self.log_level { + my_size += ::protobuf::rt::int32_size(9, v); + } + if let Some(v) = self.log_file.as_ref() { + my_size += ::protobuf::rt::string_size(10, &v); + } + if let Some(v) = self.ps.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.notify_scripts { + my_size += 1 + 1; + } + if let Some(v) = self.root.as_ref() { + my_size += ::protobuf::rt::string_size(13, &v); + } + if let Some(v) = self.parent_img.as_ref() { + my_size += ::protobuf::rt::string_size(14, &v); + } + if let Some(v) = self.track_mem { + my_size += 1 + 1; + } + if let Some(v) = self.auto_dedup { + my_size += 2 + 1; + } + if let Some(v) = self.work_dir_fd { + my_size += ::protobuf::rt::int32_size(17, v); + } + if let Some(v) = self.link_remap { + my_size += 2 + 1; + } + for value in &self.veths { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.cpu_cap { + my_size += ::protobuf::rt::uint32_size(20, v); + } + if let Some(v) = self.force_irmap { + my_size += 2 + 1; + } + for value in &self.exec_cmd { + my_size += ::protobuf::rt::string_size(22, &value); + }; + for value in &self.ext_mnt { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.manage_cgroups { + my_size += 2 + 1; + } + for value in &self.cg_root { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.rst_sibling { + my_size += 2 + 1; + } + for value in &self.inherit_fd { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.auto_ext_mnt { + my_size += 2 + 1; + } + if let Some(v) = self.ext_sharing { + my_size += 2 + 1; + } + if let Some(v) = self.ext_masters { + my_size += 2 + 1; + } + for value in &self.skip_mnt { + my_size += ::protobuf::rt::string_size(31, &value); + }; + for value in &self.enable_fs { + my_size += ::protobuf::rt::string_size(32, &value); + }; + for value in &self.unix_sk_ino { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.manage_cgroups_mode { + my_size += ::protobuf::rt::int32_size(34, v.value()); + } + if let Some(v) = self.ghost_limit { + my_size += ::protobuf::rt::uint32_size(35, v); + } + for value in &self.irmap_scan_paths { + my_size += ::protobuf::rt::string_size(36, &value); + }; + for value in &self.external { + my_size += ::protobuf::rt::string_size(37, &value); + }; + if let Some(v) = self.empty_ns { + my_size += ::protobuf::rt::uint32_size(38, v); + } + for value in &self.join_ns { + let len = value.compute_size(); + my_size += 2 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + }; + if let Some(v) = self.cgroup_props.as_ref() { + my_size += ::protobuf::rt::string_size(41, &v); + } + if let Some(v) = self.cgroup_props_file.as_ref() { + my_size += ::protobuf::rt::string_size(42, &v); + } + for value in &self.cgroup_dump_controller { + my_size += ::protobuf::rt::string_size(43, &value); + }; + if let Some(v) = self.freeze_cgroup.as_ref() { + my_size += ::protobuf::rt::string_size(44, &v); + } + if let Some(v) = self.timeout { + my_size += ::protobuf::rt::uint32_size(45, v); + } + if let Some(v) = self.tcp_skip_in_flight { + my_size += 2 + 1; + } + if let Some(v) = self.weak_sysctls { + my_size += 2 + 1; + } + if let Some(v) = self.lazy_pages { + my_size += 2 + 1; + } + if let Some(v) = self.status_fd { + my_size += ::protobuf::rt::int32_size(49, v); + } + if let Some(v) = self.orphan_pts_master { + my_size += 2 + 1; + } + if let Some(v) = self.config_file.as_ref() { + my_size += ::protobuf::rt::string_size(51, &v); + } + if let Some(v) = self.tcp_close { + my_size += 2 + 1; + } + if let Some(v) = self.lsm_profile.as_ref() { + my_size += ::protobuf::rt::string_size(53, &v); + } + if let Some(v) = self.tls_cacert.as_ref() { + my_size += ::protobuf::rt::string_size(54, &v); + } + if let Some(v) = self.tls_cacrl.as_ref() { + my_size += ::protobuf::rt::string_size(55, &v); + } + if let Some(v) = self.tls_cert.as_ref() { + my_size += ::protobuf::rt::string_size(56, &v); + } + if let Some(v) = self.tls_key.as_ref() { + my_size += ::protobuf::rt::string_size(57, &v); + } + if let Some(v) = self.tls { + my_size += 2 + 1; + } + if let Some(v) = self.tls_no_cn_verify { + my_size += 2 + 1; + } + if let Some(v) = self.cgroup_yard.as_ref() { + my_size += ::protobuf::rt::string_size(60, &v); + } + if let Some(v) = self.pre_dump_mode { + my_size += ::protobuf::rt::int32_size(61, v.value()); + } + if let Some(v) = self.pidfd_store_sk { + my_size += ::protobuf::rt::int32_size(62, v); + } + if let Some(v) = self.lsm_mount_context.as_ref() { + my_size += ::protobuf::rt::string_size(63, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.images_dir_fd { + os.write_int32(1, v)?; + } + if let Some(v) = self.pid { + os.write_int32(2, v)?; + } + if let Some(v) = self.leave_running { + os.write_bool(3, v)?; + } + if let Some(v) = self.ext_unix_sk { + os.write_bool(4, v)?; + } + if let Some(v) = self.tcp_established { + os.write_bool(5, v)?; + } + if let Some(v) = self.evasive_devices { + os.write_bool(6, v)?; + } + if let Some(v) = self.shell_job { + os.write_bool(7, v)?; + } + if let Some(v) = self.file_locks { + os.write_bool(8, v)?; + } + if let Some(v) = self.log_level { + os.write_int32(9, v)?; + } + if let Some(v) = self.log_file.as_ref() { + os.write_string(10, v)?; + } + if let Some(v) = self.ps.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(11, v, os)?; + } + if let Some(v) = self.notify_scripts { + os.write_bool(12, v)?; + } + if let Some(v) = self.root.as_ref() { + os.write_string(13, v)?; + } + if let Some(v) = self.parent_img.as_ref() { + os.write_string(14, v)?; + } + if let Some(v) = self.track_mem { + os.write_bool(15, v)?; + } + if let Some(v) = self.auto_dedup { + os.write_bool(16, v)?; + } + if let Some(v) = self.work_dir_fd { + os.write_int32(17, v)?; + } + if let Some(v) = self.link_remap { + os.write_bool(18, v)?; + } + for v in &self.veths { + ::protobuf::rt::write_message_field_with_cached_size(19, v, os)?; + }; + if let Some(v) = self.cpu_cap { + os.write_uint32(20, v)?; + } + if let Some(v) = self.force_irmap { + os.write_bool(21, v)?; + } + for v in &self.exec_cmd { + os.write_string(22, &v)?; + }; + for v in &self.ext_mnt { + ::protobuf::rt::write_message_field_with_cached_size(23, v, os)?; + }; + if let Some(v) = self.manage_cgroups { + os.write_bool(24, v)?; + } + for v in &self.cg_root { + ::protobuf::rt::write_message_field_with_cached_size(25, v, os)?; + }; + if let Some(v) = self.rst_sibling { + os.write_bool(26, v)?; + } + for v in &self.inherit_fd { + ::protobuf::rt::write_message_field_with_cached_size(27, v, os)?; + }; + if let Some(v) = self.auto_ext_mnt { + os.write_bool(28, v)?; + } + if let Some(v) = self.ext_sharing { + os.write_bool(29, v)?; + } + if let Some(v) = self.ext_masters { + os.write_bool(30, v)?; + } + for v in &self.skip_mnt { + os.write_string(31, &v)?; + }; + for v in &self.enable_fs { + os.write_string(32, &v)?; + }; + for v in &self.unix_sk_ino { + ::protobuf::rt::write_message_field_with_cached_size(33, v, os)?; + }; + if let Some(v) = self.manage_cgroups_mode { + os.write_enum(34, ::protobuf::EnumOrUnknown::value(&v))?; + } + if let Some(v) = self.ghost_limit { + os.write_uint32(35, v)?; + } + for v in &self.irmap_scan_paths { + os.write_string(36, &v)?; + }; + for v in &self.external { + os.write_string(37, &v)?; + }; + if let Some(v) = self.empty_ns { + os.write_uint32(38, v)?; + } + for v in &self.join_ns { + ::protobuf::rt::write_message_field_with_cached_size(39, v, os)?; + }; + if let Some(v) = self.cgroup_props.as_ref() { + os.write_string(41, v)?; + } + if let Some(v) = self.cgroup_props_file.as_ref() { + os.write_string(42, v)?; + } + for v in &self.cgroup_dump_controller { + os.write_string(43, &v)?; + }; + if let Some(v) = self.freeze_cgroup.as_ref() { + os.write_string(44, v)?; + } + if let Some(v) = self.timeout { + os.write_uint32(45, v)?; + } + if let Some(v) = self.tcp_skip_in_flight { + os.write_bool(46, v)?; + } + if let Some(v) = self.weak_sysctls { + os.write_bool(47, v)?; + } + if let Some(v) = self.lazy_pages { + os.write_bool(48, v)?; + } + if let Some(v) = self.status_fd { + os.write_int32(49, v)?; + } + if let Some(v) = self.orphan_pts_master { + os.write_bool(50, v)?; + } + if let Some(v) = self.config_file.as_ref() { + os.write_string(51, v)?; + } + if let Some(v) = self.tcp_close { + os.write_bool(52, v)?; + } + if let Some(v) = self.lsm_profile.as_ref() { + os.write_string(53, v)?; + } + if let Some(v) = self.tls_cacert.as_ref() { + os.write_string(54, v)?; + } + if let Some(v) = self.tls_cacrl.as_ref() { + os.write_string(55, v)?; + } + if let Some(v) = self.tls_cert.as_ref() { + os.write_string(56, v)?; + } + if let Some(v) = self.tls_key.as_ref() { + os.write_string(57, v)?; + } + if let Some(v) = self.tls { + os.write_bool(58, v)?; + } + if let Some(v) = self.tls_no_cn_verify { + os.write_bool(59, v)?; + } + if let Some(v) = self.cgroup_yard.as_ref() { + os.write_string(60, v)?; + } + if let Some(v) = self.pre_dump_mode { + os.write_enum(61, ::protobuf::EnumOrUnknown::value(&v))?; + } + if let Some(v) = self.pidfd_store_sk { + os.write_int32(62, v)?; + } + if let Some(v) = self.lsm_mount_context.as_ref() { + os.write_string(63, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_opts { + Criu_opts::new() + } + + fn clear(&mut self) { + self.images_dir_fd = ::std::option::Option::None; + self.pid = ::std::option::Option::None; + self.leave_running = ::std::option::Option::None; + self.ext_unix_sk = ::std::option::Option::None; + self.tcp_established = ::std::option::Option::None; + self.evasive_devices = ::std::option::Option::None; + self.shell_job = ::std::option::Option::None; + self.file_locks = ::std::option::Option::None; + self.log_level = ::std::option::Option::None; + self.log_file = ::std::option::Option::None; + self.ps.clear(); + self.notify_scripts = ::std::option::Option::None; + self.root = ::std::option::Option::None; + self.parent_img = ::std::option::Option::None; + self.track_mem = ::std::option::Option::None; + self.auto_dedup = ::std::option::Option::None; + self.work_dir_fd = ::std::option::Option::None; + self.link_remap = ::std::option::Option::None; + self.veths.clear(); + self.cpu_cap = ::std::option::Option::None; + self.force_irmap = ::std::option::Option::None; + self.exec_cmd.clear(); + self.ext_mnt.clear(); + self.manage_cgroups = ::std::option::Option::None; + self.cg_root.clear(); + self.rst_sibling = ::std::option::Option::None; + self.inherit_fd.clear(); + self.auto_ext_mnt = ::std::option::Option::None; + self.ext_sharing = ::std::option::Option::None; + self.ext_masters = ::std::option::Option::None; + self.skip_mnt.clear(); + self.enable_fs.clear(); + self.unix_sk_ino.clear(); + self.manage_cgroups_mode = ::std::option::Option::None; + self.ghost_limit = ::std::option::Option::None; + self.irmap_scan_paths.clear(); + self.external.clear(); + self.empty_ns = ::std::option::Option::None; + self.join_ns.clear(); + self.cgroup_props = ::std::option::Option::None; + self.cgroup_props_file = ::std::option::Option::None; + self.cgroup_dump_controller.clear(); + self.freeze_cgroup = ::std::option::Option::None; + self.timeout = ::std::option::Option::None; + self.tcp_skip_in_flight = ::std::option::Option::None; + self.weak_sysctls = ::std::option::Option::None; + self.lazy_pages = ::std::option::Option::None; + self.status_fd = ::std::option::Option::None; + self.orphan_pts_master = ::std::option::Option::None; + self.config_file = ::std::option::Option::None; + self.tcp_close = ::std::option::Option::None; + self.lsm_profile = ::std::option::Option::None; + self.tls_cacert = ::std::option::Option::None; + self.tls_cacrl = ::std::option::Option::None; + self.tls_cert = ::std::option::Option::None; + self.tls_key = ::std::option::Option::None; + self.tls = ::std::option::Option::None; + self.tls_no_cn_verify = ::std::option::Option::None; + self.cgroup_yard = ::std::option::Option::None; + self.pre_dump_mode = ::std::option::Option::None; + self.pidfd_store_sk = ::std::option::Option::None; + self.lsm_mount_context = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_opts { + static instance: Criu_opts = Criu_opts { + images_dir_fd: ::std::option::Option::None, + pid: ::std::option::Option::None, + leave_running: ::std::option::Option::None, + ext_unix_sk: ::std::option::Option::None, + tcp_established: ::std::option::Option::None, + evasive_devices: ::std::option::Option::None, + shell_job: ::std::option::Option::None, + file_locks: ::std::option::Option::None, + log_level: ::std::option::Option::None, + log_file: ::std::option::Option::None, + ps: ::protobuf::MessageField::none(), + notify_scripts: ::std::option::Option::None, + root: ::std::option::Option::None, + parent_img: ::std::option::Option::None, + track_mem: ::std::option::Option::None, + auto_dedup: ::std::option::Option::None, + work_dir_fd: ::std::option::Option::None, + link_remap: ::std::option::Option::None, + veths: ::std::vec::Vec::new(), + cpu_cap: ::std::option::Option::None, + force_irmap: ::std::option::Option::None, + exec_cmd: ::std::vec::Vec::new(), + ext_mnt: ::std::vec::Vec::new(), + manage_cgroups: ::std::option::Option::None, + cg_root: ::std::vec::Vec::new(), + rst_sibling: ::std::option::Option::None, + inherit_fd: ::std::vec::Vec::new(), + auto_ext_mnt: ::std::option::Option::None, + ext_sharing: ::std::option::Option::None, + ext_masters: ::std::option::Option::None, + skip_mnt: ::std::vec::Vec::new(), + enable_fs: ::std::vec::Vec::new(), + unix_sk_ino: ::std::vec::Vec::new(), + manage_cgroups_mode: ::std::option::Option::None, + ghost_limit: ::std::option::Option::None, + irmap_scan_paths: ::std::vec::Vec::new(), + external: ::std::vec::Vec::new(), + empty_ns: ::std::option::Option::None, + join_ns: ::std::vec::Vec::new(), + cgroup_props: ::std::option::Option::None, + cgroup_props_file: ::std::option::Option::None, + cgroup_dump_controller: ::std::vec::Vec::new(), + freeze_cgroup: ::std::option::Option::None, + timeout: ::std::option::Option::None, + tcp_skip_in_flight: ::std::option::Option::None, + weak_sysctls: ::std::option::Option::None, + lazy_pages: ::std::option::Option::None, + status_fd: ::std::option::Option::None, + orphan_pts_master: ::std::option::Option::None, + config_file: ::std::option::Option::None, + tcp_close: ::std::option::Option::None, + lsm_profile: ::std::option::Option::None, + tls_cacert: ::std::option::Option::None, + tls_cacrl: ::std::option::Option::None, + tls_cert: ::std::option::Option::None, + tls_key: ::std::option::Option::None, + tls: ::std::option::Option::None, + tls_no_cn_verify: ::std::option::Option::None, + cgroup_yard: ::std::option::Option::None, + pre_dump_mode: ::std::option::Option::None, + pidfd_store_sk: ::std::option::Option::None, + lsm_mount_context: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_opts { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_opts").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_opts { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_opts { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_dump_resp) +pub struct Criu_dump_resp { + // message fields + // @@protoc_insertion_point(field:criu_dump_resp.restored) + pub restored: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_dump_resp.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_dump_resp { + fn default() -> &'a Criu_dump_resp { + ::default_instance() + } +} + +impl Criu_dump_resp { + pub fn new() -> Criu_dump_resp { + ::std::default::Default::default() + } + + // optional bool restored = 1; + + pub fn restored(&self) -> bool { + self.restored.unwrap_or(false) + } + + pub fn clear_restored(&mut self) { + self.restored = ::std::option::Option::None; + } + + pub fn has_restored(&self) -> bool { + self.restored.is_some() + } + + // Param is passed by value, moved + pub fn set_restored(&mut self, v: bool) { + self.restored = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(1); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "restored", + |m: &Criu_dump_resp| { &m.restored }, + |m: &mut Criu_dump_resp| { &mut m.restored }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_dump_resp", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_dump_resp { + const NAME: &'static str = "criu_dump_resp"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.restored = ::std::option::Option::Some(is.read_bool()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.restored { + my_size += 1 + 1; + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.restored { + os.write_bool(1, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_dump_resp { + Criu_dump_resp::new() + } + + fn clear(&mut self) { + self.restored = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_dump_resp { + static instance: Criu_dump_resp = Criu_dump_resp { + restored: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_dump_resp { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_dump_resp").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_dump_resp { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_dump_resp { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_restore_resp) +pub struct Criu_restore_resp { + // message fields + // @@protoc_insertion_point(field:criu_restore_resp.pid) + pub pid: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_restore_resp.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_restore_resp { + fn default() -> &'a Criu_restore_resp { + ::default_instance() + } +} + +impl Criu_restore_resp { + pub fn new() -> Criu_restore_resp { + ::std::default::Default::default() + } + + // required int32 pid = 1; + + pub fn pid(&self) -> i32 { + self.pid.unwrap_or(0) + } + + pub fn clear_pid(&mut self) { + self.pid = ::std::option::Option::None; + } + + pub fn has_pid(&self) -> bool { + self.pid.is_some() + } + + // Param is passed by value, moved + pub fn set_pid(&mut self, v: i32) { + self.pid = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(1); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pid", + |m: &Criu_restore_resp| { &m.pid }, + |m: &mut Criu_restore_resp| { &mut m.pid }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_restore_resp", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_restore_resp { + const NAME: &'static str = "criu_restore_resp"; + + fn is_initialized(&self) -> bool { + if self.pid.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.pid = ::std::option::Option::Some(is.read_int32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.pid { + my_size += ::protobuf::rt::int32_size(1, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.pid { + os.write_int32(1, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_restore_resp { + Criu_restore_resp::new() + } + + fn clear(&mut self) { + self.pid = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_restore_resp { + static instance: Criu_restore_resp = Criu_restore_resp { + pid: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_restore_resp { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_restore_resp").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_restore_resp { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_restore_resp { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_notify) +pub struct Criu_notify { + // message fields + // @@protoc_insertion_point(field:criu_notify.script) + pub script: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_notify.pid) + pub pid: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_notify.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_notify { + fn default() -> &'a Criu_notify { + ::default_instance() + } +} + +impl Criu_notify { + pub fn new() -> Criu_notify { + ::std::default::Default::default() + } + + // optional string script = 1; + + pub fn script(&self) -> &str { + match self.script.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_script(&mut self) { + self.script = ::std::option::Option::None; + } + + pub fn has_script(&self) -> bool { + self.script.is_some() + } + + // Param is passed by value, moved + pub fn set_script(&mut self, v: ::std::string::String) { + self.script = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_script(&mut self) -> &mut ::std::string::String { + if self.script.is_none() { + self.script = ::std::option::Option::Some(::std::string::String::new()); + } + self.script.as_mut().unwrap() + } + + // Take field + pub fn take_script(&mut self) -> ::std::string::String { + self.script.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional int32 pid = 2; + + pub fn pid(&self) -> i32 { + self.pid.unwrap_or(0) + } + + pub fn clear_pid(&mut self) { + self.pid = ::std::option::Option::None; + } + + pub fn has_pid(&self) -> bool { + self.pid.is_some() + } + + // Param is passed by value, moved + pub fn set_pid(&mut self, v: i32) { + self.pid = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(2); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "script", + |m: &Criu_notify| { &m.script }, + |m: &mut Criu_notify| { &mut m.script }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pid", + |m: &Criu_notify| { &m.pid }, + |m: &mut Criu_notify| { &mut m.pid }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_notify", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_notify { + const NAME: &'static str = "criu_notify"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 10 => { + self.script = ::std::option::Option::Some(is.read_string()?); + }, + 16 => { + self.pid = ::std::option::Option::Some(is.read_int32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.script.as_ref() { + my_size += ::protobuf::rt::string_size(1, &v); + } + if let Some(v) = self.pid { + my_size += ::protobuf::rt::int32_size(2, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.script.as_ref() { + os.write_string(1, v)?; + } + if let Some(v) = self.pid { + os.write_int32(2, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_notify { + Criu_notify::new() + } + + fn clear(&mut self) { + self.script = ::std::option::Option::None; + self.pid = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_notify { + static instance: Criu_notify = Criu_notify { + script: ::std::option::Option::None, + pid: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_notify { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_notify").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_notify { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_notify { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_features) +pub struct Criu_features { + // message fields + // @@protoc_insertion_point(field:criu_features.mem_track) + pub mem_track: ::std::option::Option, + // @@protoc_insertion_point(field:criu_features.lazy_pages) + pub lazy_pages: ::std::option::Option, + // @@protoc_insertion_point(field:criu_features.pidfd_store) + pub pidfd_store: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_features.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_features { + fn default() -> &'a Criu_features { + ::default_instance() + } +} + +impl Criu_features { + pub fn new() -> Criu_features { + ::std::default::Default::default() + } + + // optional bool mem_track = 1; + + pub fn mem_track(&self) -> bool { + self.mem_track.unwrap_or(false) + } + + pub fn clear_mem_track(&mut self) { + self.mem_track = ::std::option::Option::None; + } + + pub fn has_mem_track(&self) -> bool { + self.mem_track.is_some() + } + + // Param is passed by value, moved + pub fn set_mem_track(&mut self, v: bool) { + self.mem_track = ::std::option::Option::Some(v); + } + + // optional bool lazy_pages = 2; + + pub fn lazy_pages(&self) -> bool { + self.lazy_pages.unwrap_or(false) + } + + pub fn clear_lazy_pages(&mut self) { + self.lazy_pages = ::std::option::Option::None; + } + + pub fn has_lazy_pages(&self) -> bool { + self.lazy_pages.is_some() + } + + // Param is passed by value, moved + pub fn set_lazy_pages(&mut self, v: bool) { + self.lazy_pages = ::std::option::Option::Some(v); + } + + // optional bool pidfd_store = 3; + + pub fn pidfd_store(&self) -> bool { + self.pidfd_store.unwrap_or(false) + } + + pub fn clear_pidfd_store(&mut self) { + self.pidfd_store = ::std::option::Option::None; + } + + pub fn has_pidfd_store(&self) -> bool { + self.pidfd_store.is_some() + } + + // Param is passed by value, moved + pub fn set_pidfd_store(&mut self, v: bool) { + self.pidfd_store = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(3); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "mem_track", + |m: &Criu_features| { &m.mem_track }, + |m: &mut Criu_features| { &mut m.mem_track }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "lazy_pages", + |m: &Criu_features| { &m.lazy_pages }, + |m: &mut Criu_features| { &mut m.lazy_pages }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pidfd_store", + |m: &Criu_features| { &m.pidfd_store }, + |m: &mut Criu_features| { &mut m.pidfd_store }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_features", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_features { + const NAME: &'static str = "criu_features"; + + fn is_initialized(&self) -> bool { + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.mem_track = ::std::option::Option::Some(is.read_bool()?); + }, + 16 => { + self.lazy_pages = ::std::option::Option::Some(is.read_bool()?); + }, + 24 => { + self.pidfd_store = ::std::option::Option::Some(is.read_bool()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.mem_track { + my_size += 1 + 1; + } + if let Some(v) = self.lazy_pages { + my_size += 1 + 1; + } + if let Some(v) = self.pidfd_store { + my_size += 1 + 1; + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.mem_track { + os.write_bool(1, v)?; + } + if let Some(v) = self.lazy_pages { + os.write_bool(2, v)?; + } + if let Some(v) = self.pidfd_store { + os.write_bool(3, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_features { + Criu_features::new() + } + + fn clear(&mut self) { + self.mem_track = ::std::option::Option::None; + self.lazy_pages = ::std::option::Option::None; + self.pidfd_store = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_features { + static instance: Criu_features = Criu_features { + mem_track: ::std::option::Option::None, + lazy_pages: ::std::option::Option::None, + pidfd_store: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_features { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_features").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_features { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_features { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_req) +pub struct Criu_req { + // message fields + // @@protoc_insertion_point(field:criu_req.type) + pub type_: ::std::option::Option<::protobuf::EnumOrUnknown>, + // @@protoc_insertion_point(field:criu_req.opts) + pub opts: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_req.notify_success) + pub notify_success: ::std::option::Option, + // @@protoc_insertion_point(field:criu_req.keep_open) + pub keep_open: ::std::option::Option, + // @@protoc_insertion_point(field:criu_req.features) + pub features: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_req.pid) + pub pid: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_req.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_req { + fn default() -> &'a Criu_req { + ::default_instance() + } +} + +impl Criu_req { + pub fn new() -> Criu_req { + ::std::default::Default::default() + } + + // required .criu_req_type type = 1; + + pub fn type_(&self) -> Criu_req_type { + match self.type_ { + Some(e) => e.enum_value_or(Criu_req_type::EMPTY), + None => Criu_req_type::EMPTY, + } + } + + pub fn clear_type_(&mut self) { + self.type_ = ::std::option::Option::None; + } + + pub fn has_type(&self) -> bool { + self.type_.is_some() + } + + // Param is passed by value, moved + pub fn set_type(&mut self, v: Criu_req_type) { + self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); + } + + // optional bool notify_success = 3; + + pub fn notify_success(&self) -> bool { + self.notify_success.unwrap_or(false) + } + + pub fn clear_notify_success(&mut self) { + self.notify_success = ::std::option::Option::None; + } + + pub fn has_notify_success(&self) -> bool { + self.notify_success.is_some() + } + + // Param is passed by value, moved + pub fn set_notify_success(&mut self, v: bool) { + self.notify_success = ::std::option::Option::Some(v); + } + + // optional bool keep_open = 4; + + pub fn keep_open(&self) -> bool { + self.keep_open.unwrap_or(false) + } + + pub fn clear_keep_open(&mut self) { + self.keep_open = ::std::option::Option::None; + } + + pub fn has_keep_open(&self) -> bool { + self.keep_open.is_some() + } + + // Param is passed by value, moved + pub fn set_keep_open(&mut self, v: bool) { + self.keep_open = ::std::option::Option::Some(v); + } + + // optional uint32 pid = 6; + + pub fn pid(&self) -> u32 { + self.pid.unwrap_or(0) + } + + pub fn clear_pid(&mut self) { + self.pid = ::std::option::Option::None; + } + + pub fn has_pid(&self) -> bool { + self.pid.is_some() + } + + // Param is passed by value, moved + pub fn set_pid(&mut self, v: u32) { + self.pid = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(6); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "type", + |m: &Criu_req| { &m.type_ }, + |m: &mut Criu_req| { &mut m.type_ }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_opts>( + "opts", + |m: &Criu_req| { &m.opts }, + |m: &mut Criu_req| { &mut m.opts }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "notify_success", + |m: &Criu_req| { &m.notify_success }, + |m: &mut Criu_req| { &mut m.notify_success }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "keep_open", + |m: &Criu_req| { &m.keep_open }, + |m: &mut Criu_req| { &mut m.keep_open }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_features>( + "features", + |m: &Criu_req| { &m.features }, + |m: &mut Criu_req| { &mut m.features }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "pid", + |m: &Criu_req| { &m.pid }, + |m: &mut Criu_req| { &mut m.pid }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_req", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_req { + const NAME: &'static str = "criu_req"; + + fn is_initialized(&self) -> bool { + if self.type_.is_none() { + return false; + } + for v in &self.opts { + if !v.is_initialized() { + return false; + } + }; + for v in &self.features { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); + }, + 18 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.opts)?; + }, + 24 => { + self.notify_success = ::std::option::Option::Some(is.read_bool()?); + }, + 32 => { + self.keep_open = ::std::option::Option::Some(is.read_bool()?); + }, + 42 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.features)?; + }, + 48 => { + self.pid = ::std::option::Option::Some(is.read_uint32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.type_ { + my_size += ::protobuf::rt::int32_size(1, v.value()); + } + if let Some(v) = self.opts.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.notify_success { + my_size += 1 + 1; + } + if let Some(v) = self.keep_open { + my_size += 1 + 1; + } + if let Some(v) = self.features.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.pid { + my_size += ::protobuf::rt::uint32_size(6, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.type_ { + os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?; + } + if let Some(v) = self.opts.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?; + } + if let Some(v) = self.notify_success { + os.write_bool(3, v)?; + } + if let Some(v) = self.keep_open { + os.write_bool(4, v)?; + } + if let Some(v) = self.features.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?; + } + if let Some(v) = self.pid { + os.write_uint32(6, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_req { + Criu_req::new() + } + + fn clear(&mut self) { + self.type_ = ::std::option::Option::None; + self.opts.clear(); + self.notify_success = ::std::option::Option::None; + self.keep_open = ::std::option::Option::None; + self.features.clear(); + self.pid = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_req { + static instance: Criu_req = Criu_req { + type_: ::std::option::Option::None, + opts: ::protobuf::MessageField::none(), + notify_success: ::std::option::Option::None, + keep_open: ::std::option::Option::None, + features: ::protobuf::MessageField::none(), + pid: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_req { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_req").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_req { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_req { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_resp) +pub struct Criu_resp { + // message fields + // @@protoc_insertion_point(field:criu_resp.type) + pub type_: ::std::option::Option<::protobuf::EnumOrUnknown>, + // @@protoc_insertion_point(field:criu_resp.success) + pub success: ::std::option::Option, + // @@protoc_insertion_point(field:criu_resp.dump) + pub dump: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.restore) + pub restore: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.notify) + pub notify: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.ps) + pub ps: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.cr_errno) + pub cr_errno: ::std::option::Option, + // @@protoc_insertion_point(field:criu_resp.features) + pub features: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.cr_errmsg) + pub cr_errmsg: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_resp.version) + pub version: ::protobuf::MessageField, + // @@protoc_insertion_point(field:criu_resp.status) + pub status: ::std::option::Option, + // special fields + // @@protoc_insertion_point(special_field:criu_resp.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_resp { + fn default() -> &'a Criu_resp { + ::default_instance() + } +} + +impl Criu_resp { + pub fn new() -> Criu_resp { + ::std::default::Default::default() + } + + // required .criu_req_type type = 1; + + pub fn type_(&self) -> Criu_req_type { + match self.type_ { + Some(e) => e.enum_value_or(Criu_req_type::EMPTY), + None => Criu_req_type::EMPTY, + } + } + + pub fn clear_type_(&mut self) { + self.type_ = ::std::option::Option::None; + } + + pub fn has_type(&self) -> bool { + self.type_.is_some() + } + + // Param is passed by value, moved + pub fn set_type(&mut self, v: Criu_req_type) { + self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v)); + } + + // required bool success = 2; + + pub fn success(&self) -> bool { + self.success.unwrap_or(false) + } + + pub fn clear_success(&mut self) { + self.success = ::std::option::Option::None; + } + + pub fn has_success(&self) -> bool { + self.success.is_some() + } + + // Param is passed by value, moved + pub fn set_success(&mut self, v: bool) { + self.success = ::std::option::Option::Some(v); + } + + // optional int32 cr_errno = 7; + + pub fn cr_errno(&self) -> i32 { + self.cr_errno.unwrap_or(0) + } + + pub fn clear_cr_errno(&mut self) { + self.cr_errno = ::std::option::Option::None; + } + + pub fn has_cr_errno(&self) -> bool { + self.cr_errno.is_some() + } + + // Param is passed by value, moved + pub fn set_cr_errno(&mut self, v: i32) { + self.cr_errno = ::std::option::Option::Some(v); + } + + // optional string cr_errmsg = 9; + + pub fn cr_errmsg(&self) -> &str { + match self.cr_errmsg.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_cr_errmsg(&mut self) { + self.cr_errmsg = ::std::option::Option::None; + } + + pub fn has_cr_errmsg(&self) -> bool { + self.cr_errmsg.is_some() + } + + // Param is passed by value, moved + pub fn set_cr_errmsg(&mut self, v: ::std::string::String) { + self.cr_errmsg = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_cr_errmsg(&mut self) -> &mut ::std::string::String { + if self.cr_errmsg.is_none() { + self.cr_errmsg = ::std::option::Option::Some(::std::string::String::new()); + } + self.cr_errmsg.as_mut().unwrap() + } + + // Take field + pub fn take_cr_errmsg(&mut self) -> ::std::string::String { + self.cr_errmsg.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional int32 status = 11; + + pub fn status(&self) -> i32 { + self.status.unwrap_or(0) + } + + pub fn clear_status(&mut self) { + self.status = ::std::option::Option::None; + } + + pub fn has_status(&self) -> bool { + self.status.is_some() + } + + // Param is passed by value, moved + pub fn set_status(&mut self, v: i32) { + self.status = ::std::option::Option::Some(v); + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(11); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "type", + |m: &Criu_resp| { &m.type_ }, + |m: &mut Criu_resp| { &mut m.type_ }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "success", + |m: &Criu_resp| { &m.success }, + |m: &mut Criu_resp| { &mut m.success }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_dump_resp>( + "dump", + |m: &Criu_resp| { &m.dump }, + |m: &mut Criu_resp| { &mut m.dump }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_restore_resp>( + "restore", + |m: &Criu_resp| { &m.restore }, + |m: &mut Criu_resp| { &mut m.restore }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_notify>( + "notify", + |m: &Criu_resp| { &m.notify }, + |m: &mut Criu_resp| { &mut m.notify }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_page_server_info>( + "ps", + |m: &Criu_resp| { &m.ps }, + |m: &mut Criu_resp| { &mut m.ps }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cr_errno", + |m: &Criu_resp| { &m.cr_errno }, + |m: &mut Criu_resp| { &mut m.cr_errno }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_features>( + "features", + |m: &Criu_resp| { &m.features }, + |m: &mut Criu_resp| { &mut m.features }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "cr_errmsg", + |m: &Criu_resp| { &m.cr_errmsg }, + |m: &mut Criu_resp| { &mut m.cr_errmsg }, + )); + fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, Criu_version>( + "version", + |m: &Criu_resp| { &m.version }, + |m: &mut Criu_resp| { &mut m.version }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "status", + |m: &Criu_resp| { &m.status }, + |m: &mut Criu_resp| { &mut m.status }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_resp", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_resp { + const NAME: &'static str = "criu_resp"; + + fn is_initialized(&self) -> bool { + if self.type_.is_none() { + return false; + } + if self.success.is_none() { + return false; + } + for v in &self.dump { + if !v.is_initialized() { + return false; + } + }; + for v in &self.restore { + if !v.is_initialized() { + return false; + } + }; + for v in &self.notify { + if !v.is_initialized() { + return false; + } + }; + for v in &self.ps { + if !v.is_initialized() { + return false; + } + }; + for v in &self.features { + if !v.is_initialized() { + return false; + } + }; + for v in &self.version { + if !v.is_initialized() { + return false; + } + }; + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?); + }, + 16 => { + self.success = ::std::option::Option::Some(is.read_bool()?); + }, + 26 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.dump)?; + }, + 34 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.restore)?; + }, + 42 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.notify)?; + }, + 50 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.ps)?; + }, + 56 => { + self.cr_errno = ::std::option::Option::Some(is.read_int32()?); + }, + 66 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.features)?; + }, + 74 => { + self.cr_errmsg = ::std::option::Option::Some(is.read_string()?); + }, + 82 => { + ::protobuf::rt::read_singular_message_into_field(is, &mut self.version)?; + }, + 88 => { + self.status = ::std::option::Option::Some(is.read_int32()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.type_ { + my_size += ::protobuf::rt::int32_size(1, v.value()); + } + if let Some(v) = self.success { + my_size += 1 + 1; + } + if let Some(v) = self.dump.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.restore.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.notify.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.ps.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.cr_errno { + my_size += ::protobuf::rt::int32_size(7, v); + } + if let Some(v) = self.features.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.cr_errmsg.as_ref() { + my_size += ::protobuf::rt::string_size(9, &v); + } + if let Some(v) = self.version.as_ref() { + let len = v.compute_size(); + my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len; + } + if let Some(v) = self.status { + my_size += ::protobuf::rt::int32_size(11, v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.type_ { + os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?; + } + if let Some(v) = self.success { + os.write_bool(2, v)?; + } + if let Some(v) = self.dump.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?; + } + if let Some(v) = self.restore.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(4, v, os)?; + } + if let Some(v) = self.notify.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(5, v, os)?; + } + if let Some(v) = self.ps.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(6, v, os)?; + } + if let Some(v) = self.cr_errno { + os.write_int32(7, v)?; + } + if let Some(v) = self.features.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(8, v, os)?; + } + if let Some(v) = self.cr_errmsg.as_ref() { + os.write_string(9, v)?; + } + if let Some(v) = self.version.as_ref() { + ::protobuf::rt::write_message_field_with_cached_size(10, v, os)?; + } + if let Some(v) = self.status { + os.write_int32(11, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_resp { + Criu_resp::new() + } + + fn clear(&mut self) { + self.type_ = ::std::option::Option::None; + self.success = ::std::option::Option::None; + self.dump.clear(); + self.restore.clear(); + self.notify.clear(); + self.ps.clear(); + self.cr_errno = ::std::option::Option::None; + self.features.clear(); + self.cr_errmsg = ::std::option::Option::None; + self.version.clear(); + self.status = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_resp { + static instance: Criu_resp = Criu_resp { + type_: ::std::option::Option::None, + success: ::std::option::Option::None, + dump: ::protobuf::MessageField::none(), + restore: ::protobuf::MessageField::none(), + notify: ::protobuf::MessageField::none(), + ps: ::protobuf::MessageField::none(), + cr_errno: ::std::option::Option::None, + features: ::protobuf::MessageField::none(), + cr_errmsg: ::std::option::Option::None, + version: ::protobuf::MessageField::none(), + status: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_resp { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_resp").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_resp { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_resp { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(PartialEq,Clone,Default,Debug)] +// @@protoc_insertion_point(message:criu_version) +pub struct Criu_version { + // message fields + // @@protoc_insertion_point(field:criu_version.major_number) + pub major_number: ::std::option::Option, + // @@protoc_insertion_point(field:criu_version.minor_number) + pub minor_number: ::std::option::Option, + // @@protoc_insertion_point(field:criu_version.gitid) + pub gitid: ::std::option::Option<::std::string::String>, + // @@protoc_insertion_point(field:criu_version.sublevel) + pub sublevel: ::std::option::Option, + // @@protoc_insertion_point(field:criu_version.extra) + pub extra: ::std::option::Option, + // @@protoc_insertion_point(field:criu_version.name) + pub name: ::std::option::Option<::std::string::String>, + // special fields + // @@protoc_insertion_point(special_field:criu_version.special_fields) + pub special_fields: ::protobuf::SpecialFields, +} + +impl<'a> ::std::default::Default for &'a Criu_version { + fn default() -> &'a Criu_version { + ::default_instance() + } +} + +impl Criu_version { + pub fn new() -> Criu_version { + ::std::default::Default::default() + } + + // required int32 major_number = 1; + + pub fn major_number(&self) -> i32 { + self.major_number.unwrap_or(0) + } + + pub fn clear_major_number(&mut self) { + self.major_number = ::std::option::Option::None; + } + + pub fn has_major_number(&self) -> bool { + self.major_number.is_some() + } + + // Param is passed by value, moved + pub fn set_major_number(&mut self, v: i32) { + self.major_number = ::std::option::Option::Some(v); + } + + // required int32 minor_number = 2; + + pub fn minor_number(&self) -> i32 { + self.minor_number.unwrap_or(0) + } + + pub fn clear_minor_number(&mut self) { + self.minor_number = ::std::option::Option::None; + } + + pub fn has_minor_number(&self) -> bool { + self.minor_number.is_some() + } + + // Param is passed by value, moved + pub fn set_minor_number(&mut self, v: i32) { + self.minor_number = ::std::option::Option::Some(v); + } + + // optional string gitid = 3; + + pub fn gitid(&self) -> &str { + match self.gitid.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_gitid(&mut self) { + self.gitid = ::std::option::Option::None; + } + + pub fn has_gitid(&self) -> bool { + self.gitid.is_some() + } + + // Param is passed by value, moved + pub fn set_gitid(&mut self, v: ::std::string::String) { + self.gitid = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_gitid(&mut self) -> &mut ::std::string::String { + if self.gitid.is_none() { + self.gitid = ::std::option::Option::Some(::std::string::String::new()); + } + self.gitid.as_mut().unwrap() + } + + // Take field + pub fn take_gitid(&mut self) -> ::std::string::String { + self.gitid.take().unwrap_or_else(|| ::std::string::String::new()) + } + + // optional int32 sublevel = 4; + + pub fn sublevel(&self) -> i32 { + self.sublevel.unwrap_or(0) + } + + pub fn clear_sublevel(&mut self) { + self.sublevel = ::std::option::Option::None; + } + + pub fn has_sublevel(&self) -> bool { + self.sublevel.is_some() + } + + // Param is passed by value, moved + pub fn set_sublevel(&mut self, v: i32) { + self.sublevel = ::std::option::Option::Some(v); + } + + // optional int32 extra = 5; + + pub fn extra(&self) -> i32 { + self.extra.unwrap_or(0) + } + + pub fn clear_extra(&mut self) { + self.extra = ::std::option::Option::None; + } + + pub fn has_extra(&self) -> bool { + self.extra.is_some() + } + + // Param is passed by value, moved + pub fn set_extra(&mut self, v: i32) { + self.extra = ::std::option::Option::Some(v); + } + + // optional string name = 6; + + pub fn name(&self) -> &str { + match self.name.as_ref() { + Some(v) => v, + None => "", + } + } + + pub fn clear_name(&mut self) { + self.name = ::std::option::Option::None; + } + + pub fn has_name(&self) -> bool { + self.name.is_some() + } + + // Param is passed by value, moved + pub fn set_name(&mut self, v: ::std::string::String) { + self.name = ::std::option::Option::Some(v); + } + + // Mutable pointer to the field. + // If field is not initialized, it is initialized with default value first. + pub fn mut_name(&mut self) -> &mut ::std::string::String { + if self.name.is_none() { + self.name = ::std::option::Option::Some(::std::string::String::new()); + } + self.name.as_mut().unwrap() + } + + // Take field + pub fn take_name(&mut self) -> ::std::string::String { + self.name.take().unwrap_or_else(|| ::std::string::String::new()) + } + + fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData { + let mut fields = ::std::vec::Vec::with_capacity(6); + let mut oneofs = ::std::vec::Vec::with_capacity(0); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "major_number", + |m: &Criu_version| { &m.major_number }, + |m: &mut Criu_version| { &mut m.major_number }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "minor_number", + |m: &Criu_version| { &m.minor_number }, + |m: &mut Criu_version| { &mut m.minor_number }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "gitid", + |m: &Criu_version| { &m.gitid }, + |m: &mut Criu_version| { &mut m.gitid }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "sublevel", + |m: &Criu_version| { &m.sublevel }, + |m: &mut Criu_version| { &mut m.sublevel }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "extra", + |m: &Criu_version| { &m.extra }, + |m: &mut Criu_version| { &mut m.extra }, + )); + fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>( + "name", + |m: &Criu_version| { &m.name }, + |m: &mut Criu_version| { &mut m.name }, + )); + ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::( + "criu_version", + fields, + oneofs, + ) + } +} + +impl ::protobuf::Message for Criu_version { + const NAME: &'static str = "criu_version"; + + fn is_initialized(&self) -> bool { + if self.major_number.is_none() { + return false; + } + if self.minor_number.is_none() { + return false; + } + true + } + + fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> { + while let Some(tag) = is.read_raw_tag_or_eof()? { + match tag { + 8 => { + self.major_number = ::std::option::Option::Some(is.read_int32()?); + }, + 16 => { + self.minor_number = ::std::option::Option::Some(is.read_int32()?); + }, + 26 => { + self.gitid = ::std::option::Option::Some(is.read_string()?); + }, + 32 => { + self.sublevel = ::std::option::Option::Some(is.read_int32()?); + }, + 40 => { + self.extra = ::std::option::Option::Some(is.read_int32()?); + }, + 50 => { + self.name = ::std::option::Option::Some(is.read_string()?); + }, + tag => { + ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?; + }, + }; + } + ::std::result::Result::Ok(()) + } + + // Compute sizes of nested messages + #[allow(unused_variables)] + fn compute_size(&self) -> u64 { + let mut my_size = 0; + if let Some(v) = self.major_number { + my_size += ::protobuf::rt::int32_size(1, v); + } + if let Some(v) = self.minor_number { + my_size += ::protobuf::rt::int32_size(2, v); + } + if let Some(v) = self.gitid.as_ref() { + my_size += ::protobuf::rt::string_size(3, &v); + } + if let Some(v) = self.sublevel { + my_size += ::protobuf::rt::int32_size(4, v); + } + if let Some(v) = self.extra { + my_size += ::protobuf::rt::int32_size(5, v); + } + if let Some(v) = self.name.as_ref() { + my_size += ::protobuf::rt::string_size(6, &v); + } + my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields()); + self.special_fields.cached_size().set(my_size as u32); + my_size + } + + fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> { + if let Some(v) = self.major_number { + os.write_int32(1, v)?; + } + if let Some(v) = self.minor_number { + os.write_int32(2, v)?; + } + if let Some(v) = self.gitid.as_ref() { + os.write_string(3, v)?; + } + if let Some(v) = self.sublevel { + os.write_int32(4, v)?; + } + if let Some(v) = self.extra { + os.write_int32(5, v)?; + } + if let Some(v) = self.name.as_ref() { + os.write_string(6, v)?; + } + os.write_unknown_fields(self.special_fields.unknown_fields())?; + ::std::result::Result::Ok(()) + } + + fn special_fields(&self) -> &::protobuf::SpecialFields { + &self.special_fields + } + + fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields { + &mut self.special_fields + } + + fn new() -> Criu_version { + Criu_version::new() + } + + fn clear(&mut self) { + self.major_number = ::std::option::Option::None; + self.minor_number = ::std::option::Option::None; + self.gitid = ::std::option::Option::None; + self.sublevel = ::std::option::Option::None; + self.extra = ::std::option::Option::None; + self.name = ::std::option::Option::None; + self.special_fields.clear(); + } + + fn default_instance() -> &'static Criu_version { + static instance: Criu_version = Criu_version { + major_number: ::std::option::Option::None, + minor_number: ::std::option::Option::None, + gitid: ::std::option::Option::None, + sublevel: ::std::option::Option::None, + extra: ::std::option::Option::None, + name: ::std::option::Option::None, + special_fields: ::protobuf::SpecialFields::new(), + }; + &instance + } +} + +impl ::protobuf::MessageFull for Criu_version { + fn descriptor() -> ::protobuf::reflect::MessageDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().message_by_package_relative_name("criu_version").unwrap()).clone() + } +} + +impl ::std::fmt::Display for Criu_version { + fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { + ::protobuf::text_format::fmt(self, f) + } +} + +impl ::protobuf::reflect::ProtobufValue for Criu_version { + type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage; +} + +#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] +// @@protoc_insertion_point(enum:criu_cg_mode) +pub enum Criu_cg_mode { + // @@protoc_insertion_point(enum_value:criu_cg_mode.IGNORE) + IGNORE = 0, + // @@protoc_insertion_point(enum_value:criu_cg_mode.CG_NONE) + CG_NONE = 1, + // @@protoc_insertion_point(enum_value:criu_cg_mode.PROPS) + PROPS = 2, + // @@protoc_insertion_point(enum_value:criu_cg_mode.SOFT) + SOFT = 3, + // @@protoc_insertion_point(enum_value:criu_cg_mode.FULL) + FULL = 4, + // @@protoc_insertion_point(enum_value:criu_cg_mode.STRICT) + STRICT = 5, + // @@protoc_insertion_point(enum_value:criu_cg_mode.DEFAULT) + DEFAULT = 6, +} + +impl ::protobuf::Enum for Criu_cg_mode { + const NAME: &'static str = "criu_cg_mode"; + + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Criu_cg_mode::IGNORE), + 1 => ::std::option::Option::Some(Criu_cg_mode::CG_NONE), + 2 => ::std::option::Option::Some(Criu_cg_mode::PROPS), + 3 => ::std::option::Option::Some(Criu_cg_mode::SOFT), + 4 => ::std::option::Option::Some(Criu_cg_mode::FULL), + 5 => ::std::option::Option::Some(Criu_cg_mode::STRICT), + 6 => ::std::option::Option::Some(Criu_cg_mode::DEFAULT), + _ => ::std::option::Option::None + } + } + + const VALUES: &'static [Criu_cg_mode] = &[ + Criu_cg_mode::IGNORE, + Criu_cg_mode::CG_NONE, + Criu_cg_mode::PROPS, + Criu_cg_mode::SOFT, + Criu_cg_mode::FULL, + Criu_cg_mode::STRICT, + Criu_cg_mode::DEFAULT, + ]; +} + +impl ::protobuf::EnumFull for Criu_cg_mode { + fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().enum_by_package_relative_name("criu_cg_mode").unwrap()).clone() + } + + fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { + let index = *self as usize; + Self::enum_descriptor().value_by_index(index) + } +} + +impl ::std::default::Default for Criu_cg_mode { + fn default() -> Self { + Criu_cg_mode::IGNORE + } +} + +impl Criu_cg_mode { + fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { + ::protobuf::reflect::GeneratedEnumDescriptorData::new::("criu_cg_mode") + } +} + +#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] +// @@protoc_insertion_point(enum:criu_pre_dump_mode) +pub enum Criu_pre_dump_mode { + // @@protoc_insertion_point(enum_value:criu_pre_dump_mode.SPLICE) + SPLICE = 1, + // @@protoc_insertion_point(enum_value:criu_pre_dump_mode.VM_READ) + VM_READ = 2, +} + +impl ::protobuf::Enum for Criu_pre_dump_mode { + const NAME: &'static str = "criu_pre_dump_mode"; + + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 1 => ::std::option::Option::Some(Criu_pre_dump_mode::SPLICE), + 2 => ::std::option::Option::Some(Criu_pre_dump_mode::VM_READ), + _ => ::std::option::Option::None + } + } + + const VALUES: &'static [Criu_pre_dump_mode] = &[ + Criu_pre_dump_mode::SPLICE, + Criu_pre_dump_mode::VM_READ, + ]; +} + +impl ::protobuf::EnumFull for Criu_pre_dump_mode { + fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().enum_by_package_relative_name("criu_pre_dump_mode").unwrap()).clone() + } + + fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { + let index = match self { + Criu_pre_dump_mode::SPLICE => 0, + Criu_pre_dump_mode::VM_READ => 1, + }; + Self::enum_descriptor().value_by_index(index) + } +} + +// Note, `Default` is implemented although default value is not 0 +impl ::std::default::Default for Criu_pre_dump_mode { + fn default() -> Self { + Criu_pre_dump_mode::SPLICE + } +} + +impl Criu_pre_dump_mode { + fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { + ::protobuf::reflect::GeneratedEnumDescriptorData::new::("criu_pre_dump_mode") + } +} + +#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)] +// @@protoc_insertion_point(enum:criu_req_type) +pub enum Criu_req_type { + // @@protoc_insertion_point(enum_value:criu_req_type.EMPTY) + EMPTY = 0, + // @@protoc_insertion_point(enum_value:criu_req_type.DUMP) + DUMP = 1, + // @@protoc_insertion_point(enum_value:criu_req_type.RESTORE) + RESTORE = 2, + // @@protoc_insertion_point(enum_value:criu_req_type.CHECK) + CHECK = 3, + // @@protoc_insertion_point(enum_value:criu_req_type.PRE_DUMP) + PRE_DUMP = 4, + // @@protoc_insertion_point(enum_value:criu_req_type.PAGE_SERVER) + PAGE_SERVER = 5, + // @@protoc_insertion_point(enum_value:criu_req_type.NOTIFY) + NOTIFY = 6, + // @@protoc_insertion_point(enum_value:criu_req_type.CPUINFO_DUMP) + CPUINFO_DUMP = 7, + // @@protoc_insertion_point(enum_value:criu_req_type.CPUINFO_CHECK) + CPUINFO_CHECK = 8, + // @@protoc_insertion_point(enum_value:criu_req_type.FEATURE_CHECK) + FEATURE_CHECK = 9, + // @@protoc_insertion_point(enum_value:criu_req_type.VERSION) + VERSION = 10, + // @@protoc_insertion_point(enum_value:criu_req_type.WAIT_PID) + WAIT_PID = 11, + // @@protoc_insertion_point(enum_value:criu_req_type.PAGE_SERVER_CHLD) + PAGE_SERVER_CHLD = 12, +} + +impl ::protobuf::Enum for Criu_req_type { + const NAME: &'static str = "criu_req_type"; + + fn value(&self) -> i32 { + *self as i32 + } + + fn from_i32(value: i32) -> ::std::option::Option { + match value { + 0 => ::std::option::Option::Some(Criu_req_type::EMPTY), + 1 => ::std::option::Option::Some(Criu_req_type::DUMP), + 2 => ::std::option::Option::Some(Criu_req_type::RESTORE), + 3 => ::std::option::Option::Some(Criu_req_type::CHECK), + 4 => ::std::option::Option::Some(Criu_req_type::PRE_DUMP), + 5 => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER), + 6 => ::std::option::Option::Some(Criu_req_type::NOTIFY), + 7 => ::std::option::Option::Some(Criu_req_type::CPUINFO_DUMP), + 8 => ::std::option::Option::Some(Criu_req_type::CPUINFO_CHECK), + 9 => ::std::option::Option::Some(Criu_req_type::FEATURE_CHECK), + 10 => ::std::option::Option::Some(Criu_req_type::VERSION), + 11 => ::std::option::Option::Some(Criu_req_type::WAIT_PID), + 12 => ::std::option::Option::Some(Criu_req_type::PAGE_SERVER_CHLD), + _ => ::std::option::Option::None + } + } + + const VALUES: &'static [Criu_req_type] = &[ + Criu_req_type::EMPTY, + Criu_req_type::DUMP, + Criu_req_type::RESTORE, + Criu_req_type::CHECK, + Criu_req_type::PRE_DUMP, + Criu_req_type::PAGE_SERVER, + Criu_req_type::NOTIFY, + Criu_req_type::CPUINFO_DUMP, + Criu_req_type::CPUINFO_CHECK, + Criu_req_type::FEATURE_CHECK, + Criu_req_type::VERSION, + Criu_req_type::WAIT_PID, + Criu_req_type::PAGE_SERVER_CHLD, + ]; +} + +impl ::protobuf::EnumFull for Criu_req_type { + fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor { + static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new(); + descriptor.get(|| file_descriptor().enum_by_package_relative_name("criu_req_type").unwrap()).clone() + } + + fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor { + let index = *self as usize; + Self::enum_descriptor().value_by_index(index) + } +} + +impl ::std::default::Default for Criu_req_type { + fn default() -> Self { + Criu_req_type::EMPTY + } +} + +impl Criu_req_type { + fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData { + ::protobuf::reflect::GeneratedEnumDescriptorData::new::("criu_req_type") + } +} + +static file_descriptor_proto_data: &'static [u8] = b"\ + \n\trpc.proto\"g\n\x15criu_page_server_info\x12\x18\n\x07address\x18\x01\ + \x20\x01(\tR\x07address\x12\x12\n\x04port\x18\x02\x20\x01(\x05R\x04port\ + \x12\x10\n\x03pid\x18\x03\x20\x01(\x05R\x03pid\x12\x0e\n\x02fd\x18\x04\ + \x20\x01(\x05R\x02fd\"<\n\x0ecriu_veth_pair\x12\x13\n\x05if_in\x18\x01\ + \x20\x02(\tR\x04ifIn\x12\x15\n\x06if_out\x18\x02\x20\x02(\tR\x05ifOut\"3\ + \n\rext_mount_map\x12\x10\n\x03key\x18\x01\x20\x02(\tR\x03key\x12\x10\n\ + \x03val\x18\x02\x20\x02(\tR\x03val\"V\n\x0ejoin_namespace\x12\x0e\n\x02n\ + s\x18\x01\x20\x02(\tR\x02ns\x12\x17\n\x07ns_file\x18\x02\x20\x02(\tR\x06\ + nsFile\x12\x1b\n\textra_opt\x18\x03\x20\x01(\tR\x08extraOpt\".\n\ninheri\ + t_fd\x12\x10\n\x03key\x18\x01\x20\x02(\tR\x03key\x12\x0e\n\x02fd\x18\x02\ + \x20\x02(\x05R\x02fd\"5\n\x0bcgroup_root\x12\x12\n\x04ctrl\x18\x01\x20\ + \x01(\tR\x04ctrl\x12\x12\n\x04path\x18\x02\x20\x02(\tR\x04path\"\x1f\n\ + \x07unix_sk\x12\x14\n\x05inode\x18\x01\x20\x02(\rR\x05inode\"\x8c\x11\n\ + \tcriu_opts\x12\"\n\rimages_dir_fd\x18\x01\x20\x02(\x05R\x0bimagesDirFd\ + \x12\x10\n\x03pid\x18\x02\x20\x01(\x05R\x03pid\x12#\n\rleave_running\x18\ + \x03\x20\x01(\x08R\x0cleaveRunning\x12\x1e\n\x0bext_unix_sk\x18\x04\x20\ + \x01(\x08R\textUnixSk\x12'\n\x0ftcp_established\x18\x05\x20\x01(\x08R\ + \x0etcpEstablished\x12'\n\x0fevasive_devices\x18\x06\x20\x01(\x08R\x0eev\ + asiveDevices\x12\x1b\n\tshell_job\x18\x07\x20\x01(\x08R\x08shellJob\x12\ + \x1d\n\nfile_locks\x18\x08\x20\x01(\x08R\tfileLocks\x12\x1e\n\tlog_level\ + \x18\t\x20\x01(\x05:\x012R\x08logLevel\x12\x19\n\x08log_file\x18\n\x20\ + \x01(\tR\x07logFile\x12&\n\x02ps\x18\x0b\x20\x01(\x0b2\x16.criu_page_ser\ + ver_infoR\x02ps\x12%\n\x0enotify_scripts\x18\x0c\x20\x01(\x08R\rnotifySc\ + ripts\x12\x12\n\x04root\x18\r\x20\x01(\tR\x04root\x12\x1d\n\nparent_img\ + \x18\x0e\x20\x01(\tR\tparentImg\x12\x1b\n\ttrack_mem\x18\x0f\x20\x01(\ + \x08R\x08trackMem\x12\x1d\n\nauto_dedup\x18\x10\x20\x01(\x08R\tautoDedup\ + \x12\x1e\n\x0bwork_dir_fd\x18\x11\x20\x01(\x05R\tworkDirFd\x12\x1d\n\nli\ + nk_remap\x18\x12\x20\x01(\x08R\tlinkRemap\x12%\n\x05veths\x18\x13\x20\ + \x03(\x0b2\x0f.criu_veth_pairR\x05veths\x12#\n\x07cpu_cap\x18\x14\x20\ + \x01(\r:\n4294967295R\x06cpuCap\x12\x1f\n\x0bforce_irmap\x18\x15\x20\x01\ + (\x08R\nforceIrmap\x12\x19\n\x08exec_cmd\x18\x16\x20\x03(\tR\x07execCmd\ + \x12'\n\x07ext_mnt\x18\x17\x20\x03(\x0b2\x0e.ext_mount_mapR\x06extMnt\ + \x12%\n\x0emanage_cgroups\x18\x18\x20\x01(\x08R\rmanageCgroups\x12%\n\ + \x07cg_root\x18\x19\x20\x03(\x0b2\x0c.cgroup_rootR\x06cgRoot\x12\x1f\n\ + \x0brst_sibling\x18\x1a\x20\x01(\x08R\nrstSibling\x12*\n\ninherit_fd\x18\ + \x1b\x20\x03(\x0b2\x0b.inherit_fdR\tinheritFd\x12\x20\n\x0cauto_ext_mnt\ + \x18\x1c\x20\x01(\x08R\nautoExtMnt\x12\x1f\n\x0bext_sharing\x18\x1d\x20\ + \x01(\x08R\nextSharing\x12\x1f\n\x0bext_masters\x18\x1e\x20\x01(\x08R\ne\ + xtMasters\x12\x19\n\x08skip_mnt\x18\x1f\x20\x03(\tR\x07skipMnt\x12\x1b\n\ + \tenable_fs\x18\x20\x20\x03(\tR\x08enableFs\x12(\n\x0bunix_sk_ino\x18!\ + \x20\x03(\x0b2\x08.unix_skR\tunixSkIno\x12=\n\x13manage_cgroups_mode\x18\ + \"\x20\x01(\x0e2\r.criu_cg_modeR\x11manageCgroupsMode\x12(\n\x0bghost_li\ + mit\x18#\x20\x01(\r:\x071048576R\nghostLimit\x12(\n\x10irmap_scan_paths\ + \x18$\x20\x03(\tR\x0eirmapScanPaths\x12\x1a\n\x08external\x18%\x20\x03(\ + \tR\x08external\x12\x19\n\x08empty_ns\x18&\x20\x01(\rR\x07emptyNs\x12(\n\ + \x07join_ns\x18'\x20\x03(\x0b2\x0f.join_namespaceR\x06joinNs\x12!\n\x0cc\ + group_props\x18)\x20\x01(\tR\x0bcgroupProps\x12*\n\x11cgroup_props_file\ + \x18*\x20\x01(\tR\x0fcgroupPropsFile\x124\n\x16cgroup_dump_controller\ + \x18+\x20\x03(\tR\x14cgroupDumpController\x12#\n\rfreeze_cgroup\x18,\x20\ + \x01(\tR\x0cfreezeCgroup\x12\x18\n\x07timeout\x18-\x20\x01(\rR\x07timeou\ + t\x12+\n\x12tcp_skip_in_flight\x18.\x20\x01(\x08R\x0ftcpSkipInFlight\x12\ + !\n\x0cweak_sysctls\x18/\x20\x01(\x08R\x0bweakSysctls\x12\x1d\n\nlazy_pa\ + ges\x180\x20\x01(\x08R\tlazyPages\x12\x1b\n\tstatus_fd\x181\x20\x01(\x05\ + R\x08statusFd\x12*\n\x11orphan_pts_master\x182\x20\x01(\x08R\x0forphanPt\ + sMaster\x12\x1f\n\x0bconfig_file\x183\x20\x01(\tR\nconfigFile\x12\x1b\n\ + \ttcp_close\x184\x20\x01(\x08R\x08tcpClose\x12\x1f\n\x0blsm_profile\x185\ + \x20\x01(\tR\nlsmProfile\x12\x1d\n\ntls_cacert\x186\x20\x01(\tR\ttlsCace\ + rt\x12\x1b\n\ttls_cacrl\x187\x20\x01(\tR\x08tlsCacrl\x12\x19\n\x08tls_ce\ + rt\x188\x20\x01(\tR\x07tlsCert\x12\x17\n\x07tls_key\x189\x20\x01(\tR\x06\ + tlsKey\x12\x10\n\x03tls\x18:\x20\x01(\x08R\x03tls\x12'\n\x10tls_no_cn_ve\ + rify\x18;\x20\x01(\x08R\rtlsNoCnVerify\x12\x1f\n\x0bcgroup_yard\x18<\x20\ + \x01(\tR\ncgroupYard\x12?\n\rpre_dump_mode\x18=\x20\x01(\x0e2\x13.criu_p\ + re_dump_mode:\x06SPLICER\x0bpreDumpMode\x12$\n\x0epidfd_store_sk\x18>\ + \x20\x01(\x05R\x0cpidfdStoreSk\x12*\n\x11lsm_mount_context\x18?\x20\x01(\ + \tR\x0flsmMountContext\",\n\x0ecriu_dump_resp\x12\x1a\n\x08restored\x18\ + \x01\x20\x01(\x08R\x08restored\"%\n\x11criu_restore_resp\x12\x10\n\x03pi\ + d\x18\x01\x20\x02(\x05R\x03pid\"7\n\x0bcriu_notify\x12\x16\n\x06script\ + \x18\x01\x20\x01(\tR\x06script\x12\x10\n\x03pid\x18\x02\x20\x01(\x05R\ + \x03pid\"l\n\rcriu_features\x12\x1b\n\tmem_track\x18\x01\x20\x01(\x08R\ + \x08memTrack\x12\x1d\n\nlazy_pages\x18\x02\x20\x01(\x08R\tlazyPages\x12\ + \x1f\n\x0bpidfd_store\x18\x03\x20\x01(\x08R\npidfdStore\"\xd0\x01\n\x08c\ + riu_req\x12\"\n\x04type\x18\x01\x20\x02(\x0e2\x0e.criu_req_typeR\x04type\ + \x12\x1e\n\x04opts\x18\x02\x20\x01(\x0b2\n.criu_optsR\x04opts\x12%\n\x0e\ + notify_success\x18\x03\x20\x01(\x08R\rnotifySuccess\x12\x1b\n\tkeep_open\ + \x18\x04\x20\x01(\x08R\x08keepOpen\x12*\n\x08features\x18\x05\x20\x01(\ + \x0b2\x0e.criu_featuresR\x08features\x12\x10\n\x03pid\x18\x06\x20\x01(\r\ + R\x03pid\"\x8f\x03\n\tcriu_resp\x12\"\n\x04type\x18\x01\x20\x02(\x0e2\ + \x0e.criu_req_typeR\x04type\x12\x18\n\x07success\x18\x02\x20\x02(\x08R\ + \x07success\x12#\n\x04dump\x18\x03\x20\x01(\x0b2\x0f.criu_dump_respR\x04\ + dump\x12,\n\x07restore\x18\x04\x20\x01(\x0b2\x12.criu_restore_respR\x07r\ + estore\x12$\n\x06notify\x18\x05\x20\x01(\x0b2\x0c.criu_notifyR\x06notify\ + \x12&\n\x02ps\x18\x06\x20\x01(\x0b2\x16.criu_page_server_infoR\x02ps\x12\ + \x19\n\x08cr_errno\x18\x07\x20\x01(\x05R\x07crErrno\x12*\n\x08features\ + \x18\x08\x20\x01(\x0b2\x0e.criu_featuresR\x08features\x12\x1b\n\tcr_errm\ + sg\x18\t\x20\x01(\tR\x08crErrmsg\x12'\n\x07version\x18\n\x20\x01(\x0b2\r\ + .criu_versionR\x07version\x12\x16\n\x06status\x18\x0b\x20\x01(\x05R\x06s\ + tatus\"\xb0\x01\n\x0ccriu_version\x12!\n\x0cmajor_number\x18\x01\x20\x02\ + (\x05R\x0bmajorNumber\x12!\n\x0cminor_number\x18\x02\x20\x02(\x05R\x0bmi\ + norNumber\x12\x14\n\x05gitid\x18\x03\x20\x01(\tR\x05gitid\x12\x1a\n\x08s\ + ublevel\x18\x04\x20\x01(\x05R\x08sublevel\x12\x14\n\x05extra\x18\x05\x20\ + \x01(\x05R\x05extra\x12\x12\n\x04name\x18\x06\x20\x01(\tR\x04name*_\n\ + \x0ccriu_cg_mode\x12\n\n\x06IGNORE\x10\0\x12\x0b\n\x07CG_NONE\x10\x01\ + \x12\t\n\x05PROPS\x10\x02\x12\x08\n\x04SOFT\x10\x03\x12\x08\n\x04FULL\ + \x10\x04\x12\n\n\x06STRICT\x10\x05\x12\x0b\n\x07DEFAULT\x10\x06*-\n\x12c\ + riu_pre_dump_mode\x12\n\n\x06SPLICE\x10\x01\x12\x0b\n\x07VM_READ\x10\x02\ + *\xd0\x01\n\rcriu_req_type\x12\t\n\x05EMPTY\x10\0\x12\x08\n\x04DUMP\x10\ + \x01\x12\x0b\n\x07RESTORE\x10\x02\x12\t\n\x05CHECK\x10\x03\x12\x0c\n\x08\ + PRE_DUMP\x10\x04\x12\x0f\n\x0bPAGE_SERVER\x10\x05\x12\n\n\x06NOTIFY\x10\ + \x06\x12\x10\n\x0cCPUINFO_DUMP\x10\x07\x12\x11\n\rCPUINFO_CHECK\x10\x08\ + \x12\x11\n\rFEATURE_CHECK\x10\t\x12\x0b\n\x07VERSION\x10\n\x12\x0c\n\x08\ + WAIT_PID\x10\x0b\x12\x14\n\x10PAGE_SERVER_CHLD\x10\x0c\ +"; + +/// `FileDescriptorProto` object which was a source for this generated file +fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { + static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new(); + file_descriptor_proto_lazy.get(|| { + ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() + }) +} + +/// `FileDescriptor` object which allows dynamic access to files +pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor { + static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new(); + static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new(); + file_descriptor.get(|| { + let generated_file_descriptor = generated_file_descriptor_lazy.get(|| { + let mut deps = ::std::vec::Vec::with_capacity(0); + let mut messages = ::std::vec::Vec::with_capacity(15); + messages.push(Criu_page_server_info::generated_message_descriptor_data()); + messages.push(Criu_veth_pair::generated_message_descriptor_data()); + messages.push(Ext_mount_map::generated_message_descriptor_data()); + messages.push(Join_namespace::generated_message_descriptor_data()); + messages.push(Inherit_fd::generated_message_descriptor_data()); + messages.push(Cgroup_root::generated_message_descriptor_data()); + messages.push(Unix_sk::generated_message_descriptor_data()); + messages.push(Criu_opts::generated_message_descriptor_data()); + messages.push(Criu_dump_resp::generated_message_descriptor_data()); + messages.push(Criu_restore_resp::generated_message_descriptor_data()); + messages.push(Criu_notify::generated_message_descriptor_data()); + messages.push(Criu_features::generated_message_descriptor_data()); + messages.push(Criu_req::generated_message_descriptor_data()); + messages.push(Criu_resp::generated_message_descriptor_data()); + messages.push(Criu_version::generated_message_descriptor_data()); + let mut enums = ::std::vec::Vec::with_capacity(3); + enums.push(Criu_cg_mode::generated_enum_descriptor_data()); + enums.push(Criu_pre_dump_mode::generated_enum_descriptor_data()); + enums.push(Criu_req_type::generated_enum_descriptor_data()); + ::protobuf::reflect::GeneratedFileDescriptor::new_generated( + file_descriptor_proto(), + deps, + messages, + enums, + ) + }); + ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor) + }) +} diff --git a/src/lib.rs b/src/lib.rs index 42c4439..d13f5f9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,8 +1,6 @@ -mod proto; - use anyhow::{Context, Result}; -use proto::rpc; use protobuf::Message; +use rust_criu_protobuf::rpc; use std::error::Error; use std::fs::File; use std::io::{Read, Write}; @@ -56,15 +54,15 @@ impl Criu { } pub fn get_criu_version(&mut self) -> Result> { - let response = self.do_swrk_with_response(rpc::criu_req_type::VERSION, None)?; + let response = self.do_swrk_with_response(rpc::Criu_req_type::VERSION, None)?; - let mut version: u32 = (response.get_version().get_major_number() * 10000) + let mut version: u32 = (response.version.major_number() * 10000) .try_into() .context("parsing criu version failed")?; - version += (response.get_version().get_minor_number() * 100) as u32; - version += response.get_version().get_sublevel() as u32; + version += (response.version.minor_number() * 100) as u32; + version += response.version.sublevel() as u32; - if response.get_version().has_gitid() { + if response.version.has_gitid() { // taken from runc: if it is a git release -> increase minor by 1 version -= version % 100; version += 100; @@ -75,9 +73,9 @@ impl Criu { fn do_swrk_with_response( &mut self, - request_type: rpc::criu_req_type, - criu_opts: Option, - ) -> Result> { + request_type: rpc::Criu_req_type, + criu_opts: Option, + ) -> Result> { if unsafe { libc::socketpair( libc::AF_LOCAL, @@ -102,11 +100,11 @@ impl Criu { })?, ); - let mut req = rpc::criu_req::new(); - req.set_field_type(request_type); + let mut req = rpc::Criu_req::new(); + req.set_type(request_type); if let Some(co) = criu_opts { - req.set_opts(co); + req.opts = protobuf::MessageField::some(co); } let mut f = unsafe { File::from_raw_fd(self.sv[0]) }; @@ -132,33 +130,29 @@ impl Criu { ) })?; - let response: rpc::criu_resp = + let response: rpc::Criu_resp = Message::parse_from_bytes(&buffer[..read]).context("parsing criu response failed")?; - if !response.get_success() { + if !response.success() { criu.unwrap() .kill() .context("killing criu process (due to failed request) failed")?; return Result::Err( format!( "CRIU RPC request failed with message:{} error:{}", - response.get_cr_errmsg(), - response.get_cr_errno() + response.cr_errmsg(), + response.cr_errno() ) .into(), ); } - if response.get_field_type() != request_type { + if response.type_() != request_type { criu.unwrap() .kill() .context("killing criu process (due to incorrect response) failed")?; return Result::Err( - format!( - "Unexpected CRIU RPC response ({:?})", - response.get_field_type() - ) - .into(), + format!("Unexpected CRIU RPC response ({:?})", response.type_()).into(), ); } @@ -224,7 +218,7 @@ impl Criu { self.work_dir_fd = fd; } - fn fill_criu_opts(&mut self, criu_opts: &mut rpc::criu_opts) { + fn fill_criu_opts(&mut self, criu_opts: &mut rpc::Criu_opts) { if self.pid != -1 { criu_opts.set_pid(self.pid); } @@ -242,15 +236,15 @@ impl Criu { } if !self.external_mounts.is_empty() { - let mut external_mounts = protobuf::RepeatedField::new(); + let mut external_mounts = Vec::new(); for e in &self.external_mounts { - let mut external_mount = rpc::ext_mount_map::new(); + let mut external_mount = rpc::Ext_mount_map::new(); external_mount.set_key(e.0.clone()); external_mount.set_val(e.1.clone()); external_mounts.push(external_mount); } self.external_mounts.clear(); - criu_opts.set_ext_mnt(external_mounts); + criu_opts.ext_mnt = external_mounts; } if self.orphan_pts_master.is_some() { @@ -308,18 +302,18 @@ impl Criu { } pub fn dump(&mut self) -> Result<(), Box> { - let mut criu_opts = rpc::criu_opts::default(); + let mut criu_opts = rpc::Criu_opts::default(); self.fill_criu_opts(&mut criu_opts); - self.do_swrk_with_response(rpc::criu_req_type::DUMP, Some(criu_opts))?; + self.do_swrk_with_response(rpc::Criu_req_type::DUMP, Some(criu_opts))?; self.clear(); Ok(()) } pub fn restore(&mut self) -> Result<(), Box> { - let mut criu_opts = rpc::criu_opts::default(); + let mut criu_opts = rpc::Criu_opts::default(); self.fill_criu_opts(&mut criu_opts); - self.do_swrk_with_response(rpc::criu_req_type::RESTORE, Some(criu_opts))?; + self.do_swrk_with_response(rpc::Criu_req_type::RESTORE, Some(criu_opts))?; self.clear(); Ok(()) diff --git a/src/proto/mod.rs b/src/proto/mod.rs deleted file mode 100644 index 06a3fd0..0000000 --- a/src/proto/mod.rs +++ /dev/null @@ -1 +0,0 @@ -pub mod rpc; diff --git a/src/proto/rpc.rs b/src/proto/rpc.rs deleted file mode 100644 index 2ef7ba6..0000000 --- a/src/proto/rpc.rs +++ /dev/null @@ -1,6958 +0,0 @@ -// This file is generated by rust-protobuf 2.28.0. Do not edit -// @generated - -// https://github.com/rust-lang/rust-clippy/issues/702 -#![allow(unknown_lints)] -#![allow(clippy::all)] - -#![allow(unused_attributes)] -#![cfg_attr(rustfmt, rustfmt::skip)] - -#![allow(box_pointers)] -#![allow(dead_code)] -#![allow(missing_docs)] -#![allow(non_camel_case_types)] -#![allow(non_snake_case)] -#![allow(non_upper_case_globals)] -#![allow(trivial_casts)] -#![allow(unused_imports)] -#![allow(unused_results)] -//! Generated file from `rpc.proto` - -/// Generated files are compatible only with the same version -/// of protobuf runtime. -// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_28_0; - -#[derive(PartialEq,Clone,Default)] -pub struct criu_page_server_info { - // message fields - address: ::protobuf::SingularField<::std::string::String>, - port: ::std::option::Option, - pid: ::std::option::Option, - fd: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_page_server_info { - fn default() -> &'a criu_page_server_info { - ::default_instance() - } -} - -impl criu_page_server_info { - pub fn new() -> criu_page_server_info { - ::std::default::Default::default() - } - - // optional string address = 1; - - - pub fn get_address(&self) -> &str { - match self.address.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_address(&mut self) { - self.address.clear(); - } - - pub fn has_address(&self) -> bool { - self.address.is_some() - } - - // Param is passed by value, moved - pub fn set_address(&mut self, v: ::std::string::String) { - self.address = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_address(&mut self) -> &mut ::std::string::String { - if self.address.is_none() { - self.address.set_default(); - } - self.address.as_mut().unwrap() - } - - // Take field - pub fn take_address(&mut self) -> ::std::string::String { - self.address.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional int32 port = 2; - - - pub fn get_port(&self) -> i32 { - self.port.unwrap_or(0) - } - pub fn clear_port(&mut self) { - self.port = ::std::option::Option::None; - } - - pub fn has_port(&self) -> bool { - self.port.is_some() - } - - // Param is passed by value, moved - pub fn set_port(&mut self, v: i32) { - self.port = ::std::option::Option::Some(v); - } - - // optional int32 pid = 3; - - - pub fn get_pid(&self) -> i32 { - self.pid.unwrap_or(0) - } - pub fn clear_pid(&mut self) { - self.pid = ::std::option::Option::None; - } - - pub fn has_pid(&self) -> bool { - self.pid.is_some() - } - - // Param is passed by value, moved - pub fn set_pid(&mut self, v: i32) { - self.pid = ::std::option::Option::Some(v); - } - - // optional int32 fd = 4; - - - pub fn get_fd(&self) -> i32 { - self.fd.unwrap_or(0) - } - pub fn clear_fd(&mut self) { - self.fd = ::std::option::Option::None; - } - - pub fn has_fd(&self) -> bool { - self.fd.is_some() - } - - // Param is passed by value, moved - pub fn set_fd(&mut self, v: i32) { - self.fd = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_page_server_info { - fn is_initialized(&self) -> bool { - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.address)?; - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.port = ::std::option::Option::Some(tmp); - }, - 3 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.pid = ::std::option::Option::Some(tmp); - }, - 4 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.fd = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.address.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(v) = self.port { - my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.pid { - my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.fd { - my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.address.as_ref() { - os.write_string(1, &v)?; - } - if let Some(v) = self.port { - os.write_int32(2, v)?; - } - if let Some(v) = self.pid { - os.write_int32(3, v)?; - } - if let Some(v) = self.fd { - os.write_int32(4, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_page_server_info { - criu_page_server_info::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "address", - |m: &criu_page_server_info| { &m.address }, - |m: &mut criu_page_server_info| { &mut m.address }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "port", - |m: &criu_page_server_info| { &m.port }, - |m: &mut criu_page_server_info| { &mut m.port }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "pid", - |m: &criu_page_server_info| { &m.pid }, - |m: &mut criu_page_server_info| { &mut m.pid }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "fd", - |m: &criu_page_server_info| { &m.fd }, - |m: &mut criu_page_server_info| { &mut m.fd }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_page_server_info", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_page_server_info { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_page_server_info::new) - } -} - -impl ::protobuf::Clear for criu_page_server_info { - fn clear(&mut self) { - self.address.clear(); - self.port = ::std::option::Option::None; - self.pid = ::std::option::Option::None; - self.fd = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_page_server_info { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_page_server_info { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_veth_pair { - // message fields - if_in: ::protobuf::SingularField<::std::string::String>, - if_out: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_veth_pair { - fn default() -> &'a criu_veth_pair { - ::default_instance() - } -} - -impl criu_veth_pair { - pub fn new() -> criu_veth_pair { - ::std::default::Default::default() - } - - // required string if_in = 1; - - - pub fn get_if_in(&self) -> &str { - match self.if_in.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_if_in(&mut self) { - self.if_in.clear(); - } - - pub fn has_if_in(&self) -> bool { - self.if_in.is_some() - } - - // Param is passed by value, moved - pub fn set_if_in(&mut self, v: ::std::string::String) { - self.if_in = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_if_in(&mut self) -> &mut ::std::string::String { - if self.if_in.is_none() { - self.if_in.set_default(); - } - self.if_in.as_mut().unwrap() - } - - // Take field - pub fn take_if_in(&mut self) -> ::std::string::String { - self.if_in.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // required string if_out = 2; - - - pub fn get_if_out(&self) -> &str { - match self.if_out.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_if_out(&mut self) { - self.if_out.clear(); - } - - pub fn has_if_out(&self) -> bool { - self.if_out.is_some() - } - - // Param is passed by value, moved - pub fn set_if_out(&mut self, v: ::std::string::String) { - self.if_out = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_if_out(&mut self) -> &mut ::std::string::String { - if self.if_out.is_none() { - self.if_out.set_default(); - } - self.if_out.as_mut().unwrap() - } - - // Take field - pub fn take_if_out(&mut self) -> ::std::string::String { - self.if_out.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for criu_veth_pair { - fn is_initialized(&self) -> bool { - if self.if_in.is_none() { - return false; - } - if self.if_out.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.if_in)?; - }, - 2 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.if_out)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.if_in.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(ref v) = self.if_out.as_ref() { - my_size += ::protobuf::rt::string_size(2, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.if_in.as_ref() { - os.write_string(1, &v)?; - } - if let Some(ref v) = self.if_out.as_ref() { - os.write_string(2, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_veth_pair { - criu_veth_pair::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "if_in", - |m: &criu_veth_pair| { &m.if_in }, - |m: &mut criu_veth_pair| { &mut m.if_in }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "if_out", - |m: &criu_veth_pair| { &m.if_out }, - |m: &mut criu_veth_pair| { &mut m.if_out }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_veth_pair", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_veth_pair { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_veth_pair::new) - } -} - -impl ::protobuf::Clear for criu_veth_pair { - fn clear(&mut self) { - self.if_in.clear(); - self.if_out.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_veth_pair { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_veth_pair { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct ext_mount_map { - // message fields - key: ::protobuf::SingularField<::std::string::String>, - val: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a ext_mount_map { - fn default() -> &'a ext_mount_map { - ::default_instance() - } -} - -impl ext_mount_map { - pub fn new() -> ext_mount_map { - ::std::default::Default::default() - } - - // required string key = 1; - - - pub fn get_key(&self) -> &str { - match self.key.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_key(&mut self) { - self.key.clear(); - } - - pub fn has_key(&self) -> bool { - self.key.is_some() - } - - // Param is passed by value, moved - pub fn set_key(&mut self, v: ::std::string::String) { - self.key = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_key(&mut self) -> &mut ::std::string::String { - if self.key.is_none() { - self.key.set_default(); - } - self.key.as_mut().unwrap() - } - - // Take field - pub fn take_key(&mut self) -> ::std::string::String { - self.key.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // required string val = 2; - - - pub fn get_val(&self) -> &str { - match self.val.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_val(&mut self) { - self.val.clear(); - } - - pub fn has_val(&self) -> bool { - self.val.is_some() - } - - // Param is passed by value, moved - pub fn set_val(&mut self, v: ::std::string::String) { - self.val = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_val(&mut self) -> &mut ::std::string::String { - if self.val.is_none() { - self.val.set_default(); - } - self.val.as_mut().unwrap() - } - - // Take field - pub fn take_val(&mut self) -> ::std::string::String { - self.val.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for ext_mount_map { - fn is_initialized(&self) -> bool { - if self.key.is_none() { - return false; - } - if self.val.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.key)?; - }, - 2 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.val)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.key.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(ref v) = self.val.as_ref() { - my_size += ::protobuf::rt::string_size(2, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.key.as_ref() { - os.write_string(1, &v)?; - } - if let Some(ref v) = self.val.as_ref() { - os.write_string(2, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> ext_mount_map { - ext_mount_map::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "key", - |m: &ext_mount_map| { &m.key }, - |m: &mut ext_mount_map| { &mut m.key }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "val", - |m: &ext_mount_map| { &m.val }, - |m: &mut ext_mount_map| { &mut m.val }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "ext_mount_map", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static ext_mount_map { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(ext_mount_map::new) - } -} - -impl ::protobuf::Clear for ext_mount_map { - fn clear(&mut self) { - self.key.clear(); - self.val.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for ext_mount_map { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for ext_mount_map { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct join_namespace { - // message fields - ns: ::protobuf::SingularField<::std::string::String>, - ns_file: ::protobuf::SingularField<::std::string::String>, - extra_opt: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a join_namespace { - fn default() -> &'a join_namespace { - ::default_instance() - } -} - -impl join_namespace { - pub fn new() -> join_namespace { - ::std::default::Default::default() - } - - // required string ns = 1; - - - pub fn get_ns(&self) -> &str { - match self.ns.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_ns(&mut self) { - self.ns.clear(); - } - - pub fn has_ns(&self) -> bool { - self.ns.is_some() - } - - // Param is passed by value, moved - pub fn set_ns(&mut self, v: ::std::string::String) { - self.ns = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_ns(&mut self) -> &mut ::std::string::String { - if self.ns.is_none() { - self.ns.set_default(); - } - self.ns.as_mut().unwrap() - } - - // Take field - pub fn take_ns(&mut self) -> ::std::string::String { - self.ns.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // required string ns_file = 2; - - - pub fn get_ns_file(&self) -> &str { - match self.ns_file.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_ns_file(&mut self) { - self.ns_file.clear(); - } - - pub fn has_ns_file(&self) -> bool { - self.ns_file.is_some() - } - - // Param is passed by value, moved - pub fn set_ns_file(&mut self, v: ::std::string::String) { - self.ns_file = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_ns_file(&mut self) -> &mut ::std::string::String { - if self.ns_file.is_none() { - self.ns_file.set_default(); - } - self.ns_file.as_mut().unwrap() - } - - // Take field - pub fn take_ns_file(&mut self) -> ::std::string::String { - self.ns_file.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string extra_opt = 3; - - - pub fn get_extra_opt(&self) -> &str { - match self.extra_opt.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_extra_opt(&mut self) { - self.extra_opt.clear(); - } - - pub fn has_extra_opt(&self) -> bool { - self.extra_opt.is_some() - } - - // Param is passed by value, moved - pub fn set_extra_opt(&mut self, v: ::std::string::String) { - self.extra_opt = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_extra_opt(&mut self) -> &mut ::std::string::String { - if self.extra_opt.is_none() { - self.extra_opt.set_default(); - } - self.extra_opt.as_mut().unwrap() - } - - // Take field - pub fn take_extra_opt(&mut self) -> ::std::string::String { - self.extra_opt.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for join_namespace { - fn is_initialized(&self) -> bool { - if self.ns.is_none() { - return false; - } - if self.ns_file.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ns)?; - }, - 2 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ns_file)?; - }, - 3 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.extra_opt)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.ns.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(ref v) = self.ns_file.as_ref() { - my_size += ::protobuf::rt::string_size(2, &v); - } - if let Some(ref v) = self.extra_opt.as_ref() { - my_size += ::protobuf::rt::string_size(3, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.ns.as_ref() { - os.write_string(1, &v)?; - } - if let Some(ref v) = self.ns_file.as_ref() { - os.write_string(2, &v)?; - } - if let Some(ref v) = self.extra_opt.as_ref() { - os.write_string(3, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> join_namespace { - join_namespace::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "ns", - |m: &join_namespace| { &m.ns }, - |m: &mut join_namespace| { &mut m.ns }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "ns_file", - |m: &join_namespace| { &m.ns_file }, - |m: &mut join_namespace| { &mut m.ns_file }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "extra_opt", - |m: &join_namespace| { &m.extra_opt }, - |m: &mut join_namespace| { &mut m.extra_opt }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "join_namespace", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static join_namespace { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(join_namespace::new) - } -} - -impl ::protobuf::Clear for join_namespace { - fn clear(&mut self) { - self.ns.clear(); - self.ns_file.clear(); - self.extra_opt.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for join_namespace { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for join_namespace { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct inherit_fd { - // message fields - key: ::protobuf::SingularField<::std::string::String>, - fd: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a inherit_fd { - fn default() -> &'a inherit_fd { - ::default_instance() - } -} - -impl inherit_fd { - pub fn new() -> inherit_fd { - ::std::default::Default::default() - } - - // required string key = 1; - - - pub fn get_key(&self) -> &str { - match self.key.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_key(&mut self) { - self.key.clear(); - } - - pub fn has_key(&self) -> bool { - self.key.is_some() - } - - // Param is passed by value, moved - pub fn set_key(&mut self, v: ::std::string::String) { - self.key = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_key(&mut self) -> &mut ::std::string::String { - if self.key.is_none() { - self.key.set_default(); - } - self.key.as_mut().unwrap() - } - - // Take field - pub fn take_key(&mut self) -> ::std::string::String { - self.key.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // required int32 fd = 2; - - - pub fn get_fd(&self) -> i32 { - self.fd.unwrap_or(0) - } - pub fn clear_fd(&mut self) { - self.fd = ::std::option::Option::None; - } - - pub fn has_fd(&self) -> bool { - self.fd.is_some() - } - - // Param is passed by value, moved - pub fn set_fd(&mut self, v: i32) { - self.fd = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for inherit_fd { - fn is_initialized(&self) -> bool { - if self.key.is_none() { - return false; - } - if self.fd.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.key)?; - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.fd = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.key.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(v) = self.fd { - my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.key.as_ref() { - os.write_string(1, &v)?; - } - if let Some(v) = self.fd { - os.write_int32(2, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> inherit_fd { - inherit_fd::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "key", - |m: &inherit_fd| { &m.key }, - |m: &mut inherit_fd| { &mut m.key }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "fd", - |m: &inherit_fd| { &m.fd }, - |m: &mut inherit_fd| { &mut m.fd }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "inherit_fd", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static inherit_fd { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(inherit_fd::new) - } -} - -impl ::protobuf::Clear for inherit_fd { - fn clear(&mut self) { - self.key.clear(); - self.fd = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for inherit_fd { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for inherit_fd { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct cgroup_root { - // message fields - ctrl: ::protobuf::SingularField<::std::string::String>, - path: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a cgroup_root { - fn default() -> &'a cgroup_root { - ::default_instance() - } -} - -impl cgroup_root { - pub fn new() -> cgroup_root { - ::std::default::Default::default() - } - - // optional string ctrl = 1; - - - pub fn get_ctrl(&self) -> &str { - match self.ctrl.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_ctrl(&mut self) { - self.ctrl.clear(); - } - - pub fn has_ctrl(&self) -> bool { - self.ctrl.is_some() - } - - // Param is passed by value, moved - pub fn set_ctrl(&mut self, v: ::std::string::String) { - self.ctrl = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_ctrl(&mut self) -> &mut ::std::string::String { - if self.ctrl.is_none() { - self.ctrl.set_default(); - } - self.ctrl.as_mut().unwrap() - } - - // Take field - pub fn take_ctrl(&mut self) -> ::std::string::String { - self.ctrl.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // required string path = 2; - - - pub fn get_path(&self) -> &str { - match self.path.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_path(&mut self) { - self.path.clear(); - } - - pub fn has_path(&self) -> bool { - self.path.is_some() - } - - // Param is passed by value, moved - pub fn set_path(&mut self, v: ::std::string::String) { - self.path = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_path(&mut self) -> &mut ::std::string::String { - if self.path.is_none() { - self.path.set_default(); - } - self.path.as_mut().unwrap() - } - - // Take field - pub fn take_path(&mut self) -> ::std::string::String { - self.path.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for cgroup_root { - fn is_initialized(&self) -> bool { - if self.path.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.ctrl)?; - }, - 2 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.path)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.ctrl.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(ref v) = self.path.as_ref() { - my_size += ::protobuf::rt::string_size(2, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.ctrl.as_ref() { - os.write_string(1, &v)?; - } - if let Some(ref v) = self.path.as_ref() { - os.write_string(2, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> cgroup_root { - cgroup_root::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "ctrl", - |m: &cgroup_root| { &m.ctrl }, - |m: &mut cgroup_root| { &mut m.ctrl }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "path", - |m: &cgroup_root| { &m.path }, - |m: &mut cgroup_root| { &mut m.path }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "cgroup_root", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static cgroup_root { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(cgroup_root::new) - } -} - -impl ::protobuf::Clear for cgroup_root { - fn clear(&mut self) { - self.ctrl.clear(); - self.path.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for cgroup_root { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for cgroup_root { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct unix_sk { - // message fields - inode: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a unix_sk { - fn default() -> &'a unix_sk { - ::default_instance() - } -} - -impl unix_sk { - pub fn new() -> unix_sk { - ::std::default::Default::default() - } - - // required uint32 inode = 1; - - - pub fn get_inode(&self) -> u32 { - self.inode.unwrap_or(0) - } - pub fn clear_inode(&mut self) { - self.inode = ::std::option::Option::None; - } - - pub fn has_inode(&self) -> bool { - self.inode.is_some() - } - - // Param is passed by value, moved - pub fn set_inode(&mut self, v: u32) { - self.inode = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for unix_sk { - fn is_initialized(&self) -> bool { - if self.inode.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.inode = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.inode { - my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.inode { - os.write_uint32(1, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> unix_sk { - unix_sk::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "inode", - |m: &unix_sk| { &m.inode }, - |m: &mut unix_sk| { &mut m.inode }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "unix_sk", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static unix_sk { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(unix_sk::new) - } -} - -impl ::protobuf::Clear for unix_sk { - fn clear(&mut self) { - self.inode = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for unix_sk { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for unix_sk { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_opts { - // message fields - images_dir_fd: ::std::option::Option, - pid: ::std::option::Option, - leave_running: ::std::option::Option, - ext_unix_sk: ::std::option::Option, - tcp_established: ::std::option::Option, - evasive_devices: ::std::option::Option, - shell_job: ::std::option::Option, - file_locks: ::std::option::Option, - log_level: ::std::option::Option, - log_file: ::protobuf::SingularField<::std::string::String>, - pub ps: ::protobuf::SingularPtrField, - notify_scripts: ::std::option::Option, - root: ::protobuf::SingularField<::std::string::String>, - parent_img: ::protobuf::SingularField<::std::string::String>, - track_mem: ::std::option::Option, - auto_dedup: ::std::option::Option, - work_dir_fd: ::std::option::Option, - link_remap: ::std::option::Option, - pub veths: ::protobuf::RepeatedField, - cpu_cap: ::std::option::Option, - force_irmap: ::std::option::Option, - pub exec_cmd: ::protobuf::RepeatedField<::std::string::String>, - pub ext_mnt: ::protobuf::RepeatedField, - manage_cgroups: ::std::option::Option, - pub cg_root: ::protobuf::RepeatedField, - rst_sibling: ::std::option::Option, - pub inherit_fd: ::protobuf::RepeatedField, - auto_ext_mnt: ::std::option::Option, - ext_sharing: ::std::option::Option, - ext_masters: ::std::option::Option, - pub skip_mnt: ::protobuf::RepeatedField<::std::string::String>, - pub enable_fs: ::protobuf::RepeatedField<::std::string::String>, - pub unix_sk_ino: ::protobuf::RepeatedField, - manage_cgroups_mode: ::std::option::Option, - ghost_limit: ::std::option::Option, - pub irmap_scan_paths: ::protobuf::RepeatedField<::std::string::String>, - pub external: ::protobuf::RepeatedField<::std::string::String>, - empty_ns: ::std::option::Option, - pub join_ns: ::protobuf::RepeatedField, - cgroup_props: ::protobuf::SingularField<::std::string::String>, - cgroup_props_file: ::protobuf::SingularField<::std::string::String>, - pub cgroup_dump_controller: ::protobuf::RepeatedField<::std::string::String>, - freeze_cgroup: ::protobuf::SingularField<::std::string::String>, - timeout: ::std::option::Option, - tcp_skip_in_flight: ::std::option::Option, - weak_sysctls: ::std::option::Option, - lazy_pages: ::std::option::Option, - status_fd: ::std::option::Option, - orphan_pts_master: ::std::option::Option, - config_file: ::protobuf::SingularField<::std::string::String>, - tcp_close: ::std::option::Option, - lsm_profile: ::protobuf::SingularField<::std::string::String>, - tls_cacert: ::protobuf::SingularField<::std::string::String>, - tls_cacrl: ::protobuf::SingularField<::std::string::String>, - tls_cert: ::protobuf::SingularField<::std::string::String>, - tls_key: ::protobuf::SingularField<::std::string::String>, - tls: ::std::option::Option, - tls_no_cn_verify: ::std::option::Option, - cgroup_yard: ::protobuf::SingularField<::std::string::String>, - pre_dump_mode: ::std::option::Option, - pidfd_store_sk: ::std::option::Option, - lsm_mount_context: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_opts { - fn default() -> &'a criu_opts { - ::default_instance() - } -} - -impl criu_opts { - pub fn new() -> criu_opts { - ::std::default::Default::default() - } - - // required int32 images_dir_fd = 1; - - - pub fn get_images_dir_fd(&self) -> i32 { - self.images_dir_fd.unwrap_or(0) - } - pub fn clear_images_dir_fd(&mut self) { - self.images_dir_fd = ::std::option::Option::None; - } - - pub fn has_images_dir_fd(&self) -> bool { - self.images_dir_fd.is_some() - } - - // Param is passed by value, moved - pub fn set_images_dir_fd(&mut self, v: i32) { - self.images_dir_fd = ::std::option::Option::Some(v); - } - - // optional int32 pid = 2; - - - pub fn get_pid(&self) -> i32 { - self.pid.unwrap_or(0) - } - pub fn clear_pid(&mut self) { - self.pid = ::std::option::Option::None; - } - - pub fn has_pid(&self) -> bool { - self.pid.is_some() - } - - // Param is passed by value, moved - pub fn set_pid(&mut self, v: i32) { - self.pid = ::std::option::Option::Some(v); - } - - // optional bool leave_running = 3; - - - pub fn get_leave_running(&self) -> bool { - self.leave_running.unwrap_or(false) - } - pub fn clear_leave_running(&mut self) { - self.leave_running = ::std::option::Option::None; - } - - pub fn has_leave_running(&self) -> bool { - self.leave_running.is_some() - } - - // Param is passed by value, moved - pub fn set_leave_running(&mut self, v: bool) { - self.leave_running = ::std::option::Option::Some(v); - } - - // optional bool ext_unix_sk = 4; - - - pub fn get_ext_unix_sk(&self) -> bool { - self.ext_unix_sk.unwrap_or(false) - } - pub fn clear_ext_unix_sk(&mut self) { - self.ext_unix_sk = ::std::option::Option::None; - } - - pub fn has_ext_unix_sk(&self) -> bool { - self.ext_unix_sk.is_some() - } - - // Param is passed by value, moved - pub fn set_ext_unix_sk(&mut self, v: bool) { - self.ext_unix_sk = ::std::option::Option::Some(v); - } - - // optional bool tcp_established = 5; - - - pub fn get_tcp_established(&self) -> bool { - self.tcp_established.unwrap_or(false) - } - pub fn clear_tcp_established(&mut self) { - self.tcp_established = ::std::option::Option::None; - } - - pub fn has_tcp_established(&self) -> bool { - self.tcp_established.is_some() - } - - // Param is passed by value, moved - pub fn set_tcp_established(&mut self, v: bool) { - self.tcp_established = ::std::option::Option::Some(v); - } - - // optional bool evasive_devices = 6; - - - pub fn get_evasive_devices(&self) -> bool { - self.evasive_devices.unwrap_or(false) - } - pub fn clear_evasive_devices(&mut self) { - self.evasive_devices = ::std::option::Option::None; - } - - pub fn has_evasive_devices(&self) -> bool { - self.evasive_devices.is_some() - } - - // Param is passed by value, moved - pub fn set_evasive_devices(&mut self, v: bool) { - self.evasive_devices = ::std::option::Option::Some(v); - } - - // optional bool shell_job = 7; - - - pub fn get_shell_job(&self) -> bool { - self.shell_job.unwrap_or(false) - } - pub fn clear_shell_job(&mut self) { - self.shell_job = ::std::option::Option::None; - } - - pub fn has_shell_job(&self) -> bool { - self.shell_job.is_some() - } - - // Param is passed by value, moved - pub fn set_shell_job(&mut self, v: bool) { - self.shell_job = ::std::option::Option::Some(v); - } - - // optional bool file_locks = 8; - - - pub fn get_file_locks(&self) -> bool { - self.file_locks.unwrap_or(false) - } - pub fn clear_file_locks(&mut self) { - self.file_locks = ::std::option::Option::None; - } - - pub fn has_file_locks(&self) -> bool { - self.file_locks.is_some() - } - - // Param is passed by value, moved - pub fn set_file_locks(&mut self, v: bool) { - self.file_locks = ::std::option::Option::Some(v); - } - - // optional int32 log_level = 9; - - - pub fn get_log_level(&self) -> i32 { - self.log_level.unwrap_or(2i32) - } - pub fn clear_log_level(&mut self) { - self.log_level = ::std::option::Option::None; - } - - pub fn has_log_level(&self) -> bool { - self.log_level.is_some() - } - - // Param is passed by value, moved - pub fn set_log_level(&mut self, v: i32) { - self.log_level = ::std::option::Option::Some(v); - } - - // optional string log_file = 10; - - - pub fn get_log_file(&self) -> &str { - match self.log_file.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_log_file(&mut self) { - self.log_file.clear(); - } - - pub fn has_log_file(&self) -> bool { - self.log_file.is_some() - } - - // Param is passed by value, moved - pub fn set_log_file(&mut self, v: ::std::string::String) { - self.log_file = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_log_file(&mut self) -> &mut ::std::string::String { - if self.log_file.is_none() { - self.log_file.set_default(); - } - self.log_file.as_mut().unwrap() - } - - // Take field - pub fn take_log_file(&mut self) -> ::std::string::String { - self.log_file.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional .criu_page_server_info ps = 11; - - - pub fn get_ps(&self) -> &criu_page_server_info { - self.ps.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_ps(&mut self) { - self.ps.clear(); - } - - pub fn has_ps(&self) -> bool { - self.ps.is_some() - } - - // Param is passed by value, moved - pub fn set_ps(&mut self, v: criu_page_server_info) { - self.ps = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_ps(&mut self) -> &mut criu_page_server_info { - if self.ps.is_none() { - self.ps.set_default(); - } - self.ps.as_mut().unwrap() - } - - // Take field - pub fn take_ps(&mut self) -> criu_page_server_info { - self.ps.take().unwrap_or_else(|| criu_page_server_info::new()) - } - - // optional bool notify_scripts = 12; - - - pub fn get_notify_scripts(&self) -> bool { - self.notify_scripts.unwrap_or(false) - } - pub fn clear_notify_scripts(&mut self) { - self.notify_scripts = ::std::option::Option::None; - } - - pub fn has_notify_scripts(&self) -> bool { - self.notify_scripts.is_some() - } - - // Param is passed by value, moved - pub fn set_notify_scripts(&mut self, v: bool) { - self.notify_scripts = ::std::option::Option::Some(v); - } - - // optional string root = 13; - - - pub fn get_root(&self) -> &str { - match self.root.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_root(&mut self) { - self.root.clear(); - } - - pub fn has_root(&self) -> bool { - self.root.is_some() - } - - // Param is passed by value, moved - pub fn set_root(&mut self, v: ::std::string::String) { - self.root = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_root(&mut self) -> &mut ::std::string::String { - if self.root.is_none() { - self.root.set_default(); - } - self.root.as_mut().unwrap() - } - - // Take field - pub fn take_root(&mut self) -> ::std::string::String { - self.root.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string parent_img = 14; - - - pub fn get_parent_img(&self) -> &str { - match self.parent_img.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_parent_img(&mut self) { - self.parent_img.clear(); - } - - pub fn has_parent_img(&self) -> bool { - self.parent_img.is_some() - } - - // Param is passed by value, moved - pub fn set_parent_img(&mut self, v: ::std::string::String) { - self.parent_img = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_parent_img(&mut self) -> &mut ::std::string::String { - if self.parent_img.is_none() { - self.parent_img.set_default(); - } - self.parent_img.as_mut().unwrap() - } - - // Take field - pub fn take_parent_img(&mut self) -> ::std::string::String { - self.parent_img.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional bool track_mem = 15; - - - pub fn get_track_mem(&self) -> bool { - self.track_mem.unwrap_or(false) - } - pub fn clear_track_mem(&mut self) { - self.track_mem = ::std::option::Option::None; - } - - pub fn has_track_mem(&self) -> bool { - self.track_mem.is_some() - } - - // Param is passed by value, moved - pub fn set_track_mem(&mut self, v: bool) { - self.track_mem = ::std::option::Option::Some(v); - } - - // optional bool auto_dedup = 16; - - - pub fn get_auto_dedup(&self) -> bool { - self.auto_dedup.unwrap_or(false) - } - pub fn clear_auto_dedup(&mut self) { - self.auto_dedup = ::std::option::Option::None; - } - - pub fn has_auto_dedup(&self) -> bool { - self.auto_dedup.is_some() - } - - // Param is passed by value, moved - pub fn set_auto_dedup(&mut self, v: bool) { - self.auto_dedup = ::std::option::Option::Some(v); - } - - // optional int32 work_dir_fd = 17; - - - pub fn get_work_dir_fd(&self) -> i32 { - self.work_dir_fd.unwrap_or(0) - } - pub fn clear_work_dir_fd(&mut self) { - self.work_dir_fd = ::std::option::Option::None; - } - - pub fn has_work_dir_fd(&self) -> bool { - self.work_dir_fd.is_some() - } - - // Param is passed by value, moved - pub fn set_work_dir_fd(&mut self, v: i32) { - self.work_dir_fd = ::std::option::Option::Some(v); - } - - // optional bool link_remap = 18; - - - pub fn get_link_remap(&self) -> bool { - self.link_remap.unwrap_or(false) - } - pub fn clear_link_remap(&mut self) { - self.link_remap = ::std::option::Option::None; - } - - pub fn has_link_remap(&self) -> bool { - self.link_remap.is_some() - } - - // Param is passed by value, moved - pub fn set_link_remap(&mut self, v: bool) { - self.link_remap = ::std::option::Option::Some(v); - } - - // repeated .criu_veth_pair veths = 19; - - - pub fn get_veths(&self) -> &[criu_veth_pair] { - &self.veths - } - pub fn clear_veths(&mut self) { - self.veths.clear(); - } - - // Param is passed by value, moved - pub fn set_veths(&mut self, v: ::protobuf::RepeatedField) { - self.veths = v; - } - - // Mutable pointer to the field. - pub fn mut_veths(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.veths - } - - // Take field - pub fn take_veths(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.veths, ::protobuf::RepeatedField::new()) - } - - // optional uint32 cpu_cap = 20; - - - pub fn get_cpu_cap(&self) -> u32 { - self.cpu_cap.unwrap_or(4294967295u32) - } - pub fn clear_cpu_cap(&mut self) { - self.cpu_cap = ::std::option::Option::None; - } - - pub fn has_cpu_cap(&self) -> bool { - self.cpu_cap.is_some() - } - - // Param is passed by value, moved - pub fn set_cpu_cap(&mut self, v: u32) { - self.cpu_cap = ::std::option::Option::Some(v); - } - - // optional bool force_irmap = 21; - - - pub fn get_force_irmap(&self) -> bool { - self.force_irmap.unwrap_or(false) - } - pub fn clear_force_irmap(&mut self) { - self.force_irmap = ::std::option::Option::None; - } - - pub fn has_force_irmap(&self) -> bool { - self.force_irmap.is_some() - } - - // Param is passed by value, moved - pub fn set_force_irmap(&mut self, v: bool) { - self.force_irmap = ::std::option::Option::Some(v); - } - - // repeated string exec_cmd = 22; - - - pub fn get_exec_cmd(&self) -> &[::std::string::String] { - &self.exec_cmd - } - pub fn clear_exec_cmd(&mut self) { - self.exec_cmd.clear(); - } - - // Param is passed by value, moved - pub fn set_exec_cmd(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.exec_cmd = v; - } - - // Mutable pointer to the field. - pub fn mut_exec_cmd(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.exec_cmd - } - - // Take field - pub fn take_exec_cmd(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.exec_cmd, ::protobuf::RepeatedField::new()) - } - - // repeated .ext_mount_map ext_mnt = 23; - - - pub fn get_ext_mnt(&self) -> &[ext_mount_map] { - &self.ext_mnt - } - pub fn clear_ext_mnt(&mut self) { - self.ext_mnt.clear(); - } - - // Param is passed by value, moved - pub fn set_ext_mnt(&mut self, v: ::protobuf::RepeatedField) { - self.ext_mnt = v; - } - - // Mutable pointer to the field. - pub fn mut_ext_mnt(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.ext_mnt - } - - // Take field - pub fn take_ext_mnt(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.ext_mnt, ::protobuf::RepeatedField::new()) - } - - // optional bool manage_cgroups = 24; - - - pub fn get_manage_cgroups(&self) -> bool { - self.manage_cgroups.unwrap_or(false) - } - pub fn clear_manage_cgroups(&mut self) { - self.manage_cgroups = ::std::option::Option::None; - } - - pub fn has_manage_cgroups(&self) -> bool { - self.manage_cgroups.is_some() - } - - // Param is passed by value, moved - pub fn set_manage_cgroups(&mut self, v: bool) { - self.manage_cgroups = ::std::option::Option::Some(v); - } - - // repeated .cgroup_root cg_root = 25; - - - pub fn get_cg_root(&self) -> &[cgroup_root] { - &self.cg_root - } - pub fn clear_cg_root(&mut self) { - self.cg_root.clear(); - } - - // Param is passed by value, moved - pub fn set_cg_root(&mut self, v: ::protobuf::RepeatedField) { - self.cg_root = v; - } - - // Mutable pointer to the field. - pub fn mut_cg_root(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.cg_root - } - - // Take field - pub fn take_cg_root(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.cg_root, ::protobuf::RepeatedField::new()) - } - - // optional bool rst_sibling = 26; - - - pub fn get_rst_sibling(&self) -> bool { - self.rst_sibling.unwrap_or(false) - } - pub fn clear_rst_sibling(&mut self) { - self.rst_sibling = ::std::option::Option::None; - } - - pub fn has_rst_sibling(&self) -> bool { - self.rst_sibling.is_some() - } - - // Param is passed by value, moved - pub fn set_rst_sibling(&mut self, v: bool) { - self.rst_sibling = ::std::option::Option::Some(v); - } - - // repeated .inherit_fd inherit_fd = 27; - - - pub fn get_inherit_fd(&self) -> &[inherit_fd] { - &self.inherit_fd - } - pub fn clear_inherit_fd(&mut self) { - self.inherit_fd.clear(); - } - - // Param is passed by value, moved - pub fn set_inherit_fd(&mut self, v: ::protobuf::RepeatedField) { - self.inherit_fd = v; - } - - // Mutable pointer to the field. - pub fn mut_inherit_fd(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.inherit_fd - } - - // Take field - pub fn take_inherit_fd(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.inherit_fd, ::protobuf::RepeatedField::new()) - } - - // optional bool auto_ext_mnt = 28; - - - pub fn get_auto_ext_mnt(&self) -> bool { - self.auto_ext_mnt.unwrap_or(false) - } - pub fn clear_auto_ext_mnt(&mut self) { - self.auto_ext_mnt = ::std::option::Option::None; - } - - pub fn has_auto_ext_mnt(&self) -> bool { - self.auto_ext_mnt.is_some() - } - - // Param is passed by value, moved - pub fn set_auto_ext_mnt(&mut self, v: bool) { - self.auto_ext_mnt = ::std::option::Option::Some(v); - } - - // optional bool ext_sharing = 29; - - - pub fn get_ext_sharing(&self) -> bool { - self.ext_sharing.unwrap_or(false) - } - pub fn clear_ext_sharing(&mut self) { - self.ext_sharing = ::std::option::Option::None; - } - - pub fn has_ext_sharing(&self) -> bool { - self.ext_sharing.is_some() - } - - // Param is passed by value, moved - pub fn set_ext_sharing(&mut self, v: bool) { - self.ext_sharing = ::std::option::Option::Some(v); - } - - // optional bool ext_masters = 30; - - - pub fn get_ext_masters(&self) -> bool { - self.ext_masters.unwrap_or(false) - } - pub fn clear_ext_masters(&mut self) { - self.ext_masters = ::std::option::Option::None; - } - - pub fn has_ext_masters(&self) -> bool { - self.ext_masters.is_some() - } - - // Param is passed by value, moved - pub fn set_ext_masters(&mut self, v: bool) { - self.ext_masters = ::std::option::Option::Some(v); - } - - // repeated string skip_mnt = 31; - - - pub fn get_skip_mnt(&self) -> &[::std::string::String] { - &self.skip_mnt - } - pub fn clear_skip_mnt(&mut self) { - self.skip_mnt.clear(); - } - - // Param is passed by value, moved - pub fn set_skip_mnt(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.skip_mnt = v; - } - - // Mutable pointer to the field. - pub fn mut_skip_mnt(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.skip_mnt - } - - // Take field - pub fn take_skip_mnt(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.skip_mnt, ::protobuf::RepeatedField::new()) - } - - // repeated string enable_fs = 32; - - - pub fn get_enable_fs(&self) -> &[::std::string::String] { - &self.enable_fs - } - pub fn clear_enable_fs(&mut self) { - self.enable_fs.clear(); - } - - // Param is passed by value, moved - pub fn set_enable_fs(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.enable_fs = v; - } - - // Mutable pointer to the field. - pub fn mut_enable_fs(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.enable_fs - } - - // Take field - pub fn take_enable_fs(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.enable_fs, ::protobuf::RepeatedField::new()) - } - - // repeated .unix_sk unix_sk_ino = 33; - - - pub fn get_unix_sk_ino(&self) -> &[unix_sk] { - &self.unix_sk_ino - } - pub fn clear_unix_sk_ino(&mut self) { - self.unix_sk_ino.clear(); - } - - // Param is passed by value, moved - pub fn set_unix_sk_ino(&mut self, v: ::protobuf::RepeatedField) { - self.unix_sk_ino = v; - } - - // Mutable pointer to the field. - pub fn mut_unix_sk_ino(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.unix_sk_ino - } - - // Take field - pub fn take_unix_sk_ino(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.unix_sk_ino, ::protobuf::RepeatedField::new()) - } - - // optional .criu_cg_mode manage_cgroups_mode = 34; - - - pub fn get_manage_cgroups_mode(&self) -> criu_cg_mode { - self.manage_cgroups_mode.unwrap_or(criu_cg_mode::IGNORE) - } - pub fn clear_manage_cgroups_mode(&mut self) { - self.manage_cgroups_mode = ::std::option::Option::None; - } - - pub fn has_manage_cgroups_mode(&self) -> bool { - self.manage_cgroups_mode.is_some() - } - - // Param is passed by value, moved - pub fn set_manage_cgroups_mode(&mut self, v: criu_cg_mode) { - self.manage_cgroups_mode = ::std::option::Option::Some(v); - } - - // optional uint32 ghost_limit = 35; - - - pub fn get_ghost_limit(&self) -> u32 { - self.ghost_limit.unwrap_or(1048576u32) - } - pub fn clear_ghost_limit(&mut self) { - self.ghost_limit = ::std::option::Option::None; - } - - pub fn has_ghost_limit(&self) -> bool { - self.ghost_limit.is_some() - } - - // Param is passed by value, moved - pub fn set_ghost_limit(&mut self, v: u32) { - self.ghost_limit = ::std::option::Option::Some(v); - } - - // repeated string irmap_scan_paths = 36; - - - pub fn get_irmap_scan_paths(&self) -> &[::std::string::String] { - &self.irmap_scan_paths - } - pub fn clear_irmap_scan_paths(&mut self) { - self.irmap_scan_paths.clear(); - } - - // Param is passed by value, moved - pub fn set_irmap_scan_paths(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.irmap_scan_paths = v; - } - - // Mutable pointer to the field. - pub fn mut_irmap_scan_paths(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.irmap_scan_paths - } - - // Take field - pub fn take_irmap_scan_paths(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.irmap_scan_paths, ::protobuf::RepeatedField::new()) - } - - // repeated string external = 37; - - - pub fn get_external(&self) -> &[::std::string::String] { - &self.external - } - pub fn clear_external(&mut self) { - self.external.clear(); - } - - // Param is passed by value, moved - pub fn set_external(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.external = v; - } - - // Mutable pointer to the field. - pub fn mut_external(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.external - } - - // Take field - pub fn take_external(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.external, ::protobuf::RepeatedField::new()) - } - - // optional uint32 empty_ns = 38; - - - pub fn get_empty_ns(&self) -> u32 { - self.empty_ns.unwrap_or(0) - } - pub fn clear_empty_ns(&mut self) { - self.empty_ns = ::std::option::Option::None; - } - - pub fn has_empty_ns(&self) -> bool { - self.empty_ns.is_some() - } - - // Param is passed by value, moved - pub fn set_empty_ns(&mut self, v: u32) { - self.empty_ns = ::std::option::Option::Some(v); - } - - // repeated .join_namespace join_ns = 39; - - - pub fn get_join_ns(&self) -> &[join_namespace] { - &self.join_ns - } - pub fn clear_join_ns(&mut self) { - self.join_ns.clear(); - } - - // Param is passed by value, moved - pub fn set_join_ns(&mut self, v: ::protobuf::RepeatedField) { - self.join_ns = v; - } - - // Mutable pointer to the field. - pub fn mut_join_ns(&mut self) -> &mut ::protobuf::RepeatedField { - &mut self.join_ns - } - - // Take field - pub fn take_join_ns(&mut self) -> ::protobuf::RepeatedField { - ::std::mem::replace(&mut self.join_ns, ::protobuf::RepeatedField::new()) - } - - // optional string cgroup_props = 41; - - - pub fn get_cgroup_props(&self) -> &str { - match self.cgroup_props.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_cgroup_props(&mut self) { - self.cgroup_props.clear(); - } - - pub fn has_cgroup_props(&self) -> bool { - self.cgroup_props.is_some() - } - - // Param is passed by value, moved - pub fn set_cgroup_props(&mut self, v: ::std::string::String) { - self.cgroup_props = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_cgroup_props(&mut self) -> &mut ::std::string::String { - if self.cgroup_props.is_none() { - self.cgroup_props.set_default(); - } - self.cgroup_props.as_mut().unwrap() - } - - // Take field - pub fn take_cgroup_props(&mut self) -> ::std::string::String { - self.cgroup_props.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string cgroup_props_file = 42; - - - pub fn get_cgroup_props_file(&self) -> &str { - match self.cgroup_props_file.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_cgroup_props_file(&mut self) { - self.cgroup_props_file.clear(); - } - - pub fn has_cgroup_props_file(&self) -> bool { - self.cgroup_props_file.is_some() - } - - // Param is passed by value, moved - pub fn set_cgroup_props_file(&mut self, v: ::std::string::String) { - self.cgroup_props_file = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_cgroup_props_file(&mut self) -> &mut ::std::string::String { - if self.cgroup_props_file.is_none() { - self.cgroup_props_file.set_default(); - } - self.cgroup_props_file.as_mut().unwrap() - } - - // Take field - pub fn take_cgroup_props_file(&mut self) -> ::std::string::String { - self.cgroup_props_file.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // repeated string cgroup_dump_controller = 43; - - - pub fn get_cgroup_dump_controller(&self) -> &[::std::string::String] { - &self.cgroup_dump_controller - } - pub fn clear_cgroup_dump_controller(&mut self) { - self.cgroup_dump_controller.clear(); - } - - // Param is passed by value, moved - pub fn set_cgroup_dump_controller(&mut self, v: ::protobuf::RepeatedField<::std::string::String>) { - self.cgroup_dump_controller = v; - } - - // Mutable pointer to the field. - pub fn mut_cgroup_dump_controller(&mut self) -> &mut ::protobuf::RepeatedField<::std::string::String> { - &mut self.cgroup_dump_controller - } - - // Take field - pub fn take_cgroup_dump_controller(&mut self) -> ::protobuf::RepeatedField<::std::string::String> { - ::std::mem::replace(&mut self.cgroup_dump_controller, ::protobuf::RepeatedField::new()) - } - - // optional string freeze_cgroup = 44; - - - pub fn get_freeze_cgroup(&self) -> &str { - match self.freeze_cgroup.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_freeze_cgroup(&mut self) { - self.freeze_cgroup.clear(); - } - - pub fn has_freeze_cgroup(&self) -> bool { - self.freeze_cgroup.is_some() - } - - // Param is passed by value, moved - pub fn set_freeze_cgroup(&mut self, v: ::std::string::String) { - self.freeze_cgroup = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_freeze_cgroup(&mut self) -> &mut ::std::string::String { - if self.freeze_cgroup.is_none() { - self.freeze_cgroup.set_default(); - } - self.freeze_cgroup.as_mut().unwrap() - } - - // Take field - pub fn take_freeze_cgroup(&mut self) -> ::std::string::String { - self.freeze_cgroup.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional uint32 timeout = 45; - - - pub fn get_timeout(&self) -> u32 { - self.timeout.unwrap_or(0) - } - pub fn clear_timeout(&mut self) { - self.timeout = ::std::option::Option::None; - } - - pub fn has_timeout(&self) -> bool { - self.timeout.is_some() - } - - // Param is passed by value, moved - pub fn set_timeout(&mut self, v: u32) { - self.timeout = ::std::option::Option::Some(v); - } - - // optional bool tcp_skip_in_flight = 46; - - - pub fn get_tcp_skip_in_flight(&self) -> bool { - self.tcp_skip_in_flight.unwrap_or(false) - } - pub fn clear_tcp_skip_in_flight(&mut self) { - self.tcp_skip_in_flight = ::std::option::Option::None; - } - - pub fn has_tcp_skip_in_flight(&self) -> bool { - self.tcp_skip_in_flight.is_some() - } - - // Param is passed by value, moved - pub fn set_tcp_skip_in_flight(&mut self, v: bool) { - self.tcp_skip_in_flight = ::std::option::Option::Some(v); - } - - // optional bool weak_sysctls = 47; - - - pub fn get_weak_sysctls(&self) -> bool { - self.weak_sysctls.unwrap_or(false) - } - pub fn clear_weak_sysctls(&mut self) { - self.weak_sysctls = ::std::option::Option::None; - } - - pub fn has_weak_sysctls(&self) -> bool { - self.weak_sysctls.is_some() - } - - // Param is passed by value, moved - pub fn set_weak_sysctls(&mut self, v: bool) { - self.weak_sysctls = ::std::option::Option::Some(v); - } - - // optional bool lazy_pages = 48; - - - pub fn get_lazy_pages(&self) -> bool { - self.lazy_pages.unwrap_or(false) - } - pub fn clear_lazy_pages(&mut self) { - self.lazy_pages = ::std::option::Option::None; - } - - pub fn has_lazy_pages(&self) -> bool { - self.lazy_pages.is_some() - } - - // Param is passed by value, moved - pub fn set_lazy_pages(&mut self, v: bool) { - self.lazy_pages = ::std::option::Option::Some(v); - } - - // optional int32 status_fd = 49; - - - pub fn get_status_fd(&self) -> i32 { - self.status_fd.unwrap_or(0) - } - pub fn clear_status_fd(&mut self) { - self.status_fd = ::std::option::Option::None; - } - - pub fn has_status_fd(&self) -> bool { - self.status_fd.is_some() - } - - // Param is passed by value, moved - pub fn set_status_fd(&mut self, v: i32) { - self.status_fd = ::std::option::Option::Some(v); - } - - // optional bool orphan_pts_master = 50; - - - pub fn get_orphan_pts_master(&self) -> bool { - self.orphan_pts_master.unwrap_or(false) - } - pub fn clear_orphan_pts_master(&mut self) { - self.orphan_pts_master = ::std::option::Option::None; - } - - pub fn has_orphan_pts_master(&self) -> bool { - self.orphan_pts_master.is_some() - } - - // Param is passed by value, moved - pub fn set_orphan_pts_master(&mut self, v: bool) { - self.orphan_pts_master = ::std::option::Option::Some(v); - } - - // optional string config_file = 51; - - - pub fn get_config_file(&self) -> &str { - match self.config_file.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_config_file(&mut self) { - self.config_file.clear(); - } - - pub fn has_config_file(&self) -> bool { - self.config_file.is_some() - } - - // Param is passed by value, moved - pub fn set_config_file(&mut self, v: ::std::string::String) { - self.config_file = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_config_file(&mut self) -> &mut ::std::string::String { - if self.config_file.is_none() { - self.config_file.set_default(); - } - self.config_file.as_mut().unwrap() - } - - // Take field - pub fn take_config_file(&mut self) -> ::std::string::String { - self.config_file.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional bool tcp_close = 52; - - - pub fn get_tcp_close(&self) -> bool { - self.tcp_close.unwrap_or(false) - } - pub fn clear_tcp_close(&mut self) { - self.tcp_close = ::std::option::Option::None; - } - - pub fn has_tcp_close(&self) -> bool { - self.tcp_close.is_some() - } - - // Param is passed by value, moved - pub fn set_tcp_close(&mut self, v: bool) { - self.tcp_close = ::std::option::Option::Some(v); - } - - // optional string lsm_profile = 53; - - - pub fn get_lsm_profile(&self) -> &str { - match self.lsm_profile.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_lsm_profile(&mut self) { - self.lsm_profile.clear(); - } - - pub fn has_lsm_profile(&self) -> bool { - self.lsm_profile.is_some() - } - - // Param is passed by value, moved - pub fn set_lsm_profile(&mut self, v: ::std::string::String) { - self.lsm_profile = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_lsm_profile(&mut self) -> &mut ::std::string::String { - if self.lsm_profile.is_none() { - self.lsm_profile.set_default(); - } - self.lsm_profile.as_mut().unwrap() - } - - // Take field - pub fn take_lsm_profile(&mut self) -> ::std::string::String { - self.lsm_profile.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string tls_cacert = 54; - - - pub fn get_tls_cacert(&self) -> &str { - match self.tls_cacert.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_tls_cacert(&mut self) { - self.tls_cacert.clear(); - } - - pub fn has_tls_cacert(&self) -> bool { - self.tls_cacert.is_some() - } - - // Param is passed by value, moved - pub fn set_tls_cacert(&mut self, v: ::std::string::String) { - self.tls_cacert = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_tls_cacert(&mut self) -> &mut ::std::string::String { - if self.tls_cacert.is_none() { - self.tls_cacert.set_default(); - } - self.tls_cacert.as_mut().unwrap() - } - - // Take field - pub fn take_tls_cacert(&mut self) -> ::std::string::String { - self.tls_cacert.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string tls_cacrl = 55; - - - pub fn get_tls_cacrl(&self) -> &str { - match self.tls_cacrl.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_tls_cacrl(&mut self) { - self.tls_cacrl.clear(); - } - - pub fn has_tls_cacrl(&self) -> bool { - self.tls_cacrl.is_some() - } - - // Param is passed by value, moved - pub fn set_tls_cacrl(&mut self, v: ::std::string::String) { - self.tls_cacrl = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_tls_cacrl(&mut self) -> &mut ::std::string::String { - if self.tls_cacrl.is_none() { - self.tls_cacrl.set_default(); - } - self.tls_cacrl.as_mut().unwrap() - } - - // Take field - pub fn take_tls_cacrl(&mut self) -> ::std::string::String { - self.tls_cacrl.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string tls_cert = 56; - - - pub fn get_tls_cert(&self) -> &str { - match self.tls_cert.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_tls_cert(&mut self) { - self.tls_cert.clear(); - } - - pub fn has_tls_cert(&self) -> bool { - self.tls_cert.is_some() - } - - // Param is passed by value, moved - pub fn set_tls_cert(&mut self, v: ::std::string::String) { - self.tls_cert = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_tls_cert(&mut self) -> &mut ::std::string::String { - if self.tls_cert.is_none() { - self.tls_cert.set_default(); - } - self.tls_cert.as_mut().unwrap() - } - - // Take field - pub fn take_tls_cert(&mut self) -> ::std::string::String { - self.tls_cert.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional string tls_key = 57; - - - pub fn get_tls_key(&self) -> &str { - match self.tls_key.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_tls_key(&mut self) { - self.tls_key.clear(); - } - - pub fn has_tls_key(&self) -> bool { - self.tls_key.is_some() - } - - // Param is passed by value, moved - pub fn set_tls_key(&mut self, v: ::std::string::String) { - self.tls_key = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_tls_key(&mut self) -> &mut ::std::string::String { - if self.tls_key.is_none() { - self.tls_key.set_default(); - } - self.tls_key.as_mut().unwrap() - } - - // Take field - pub fn take_tls_key(&mut self) -> ::std::string::String { - self.tls_key.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional bool tls = 58; - - - pub fn get_tls(&self) -> bool { - self.tls.unwrap_or(false) - } - pub fn clear_tls(&mut self) { - self.tls = ::std::option::Option::None; - } - - pub fn has_tls(&self) -> bool { - self.tls.is_some() - } - - // Param is passed by value, moved - pub fn set_tls(&mut self, v: bool) { - self.tls = ::std::option::Option::Some(v); - } - - // optional bool tls_no_cn_verify = 59; - - - pub fn get_tls_no_cn_verify(&self) -> bool { - self.tls_no_cn_verify.unwrap_or(false) - } - pub fn clear_tls_no_cn_verify(&mut self) { - self.tls_no_cn_verify = ::std::option::Option::None; - } - - pub fn has_tls_no_cn_verify(&self) -> bool { - self.tls_no_cn_verify.is_some() - } - - // Param is passed by value, moved - pub fn set_tls_no_cn_verify(&mut self, v: bool) { - self.tls_no_cn_verify = ::std::option::Option::Some(v); - } - - // optional string cgroup_yard = 60; - - - pub fn get_cgroup_yard(&self) -> &str { - match self.cgroup_yard.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_cgroup_yard(&mut self) { - self.cgroup_yard.clear(); - } - - pub fn has_cgroup_yard(&self) -> bool { - self.cgroup_yard.is_some() - } - - // Param is passed by value, moved - pub fn set_cgroup_yard(&mut self, v: ::std::string::String) { - self.cgroup_yard = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_cgroup_yard(&mut self) -> &mut ::std::string::String { - if self.cgroup_yard.is_none() { - self.cgroup_yard.set_default(); - } - self.cgroup_yard.as_mut().unwrap() - } - - // Take field - pub fn take_cgroup_yard(&mut self) -> ::std::string::String { - self.cgroup_yard.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional .criu_pre_dump_mode pre_dump_mode = 61; - - - pub fn get_pre_dump_mode(&self) -> criu_pre_dump_mode { - self.pre_dump_mode.unwrap_or(criu_pre_dump_mode::SPLICE) - } - pub fn clear_pre_dump_mode(&mut self) { - self.pre_dump_mode = ::std::option::Option::None; - } - - pub fn has_pre_dump_mode(&self) -> bool { - self.pre_dump_mode.is_some() - } - - // Param is passed by value, moved - pub fn set_pre_dump_mode(&mut self, v: criu_pre_dump_mode) { - self.pre_dump_mode = ::std::option::Option::Some(v); - } - - // optional int32 pidfd_store_sk = 62; - - - pub fn get_pidfd_store_sk(&self) -> i32 { - self.pidfd_store_sk.unwrap_or(0) - } - pub fn clear_pidfd_store_sk(&mut self) { - self.pidfd_store_sk = ::std::option::Option::None; - } - - pub fn has_pidfd_store_sk(&self) -> bool { - self.pidfd_store_sk.is_some() - } - - // Param is passed by value, moved - pub fn set_pidfd_store_sk(&mut self, v: i32) { - self.pidfd_store_sk = ::std::option::Option::Some(v); - } - - // optional string lsm_mount_context = 63; - - - pub fn get_lsm_mount_context(&self) -> &str { - match self.lsm_mount_context.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_lsm_mount_context(&mut self) { - self.lsm_mount_context.clear(); - } - - pub fn has_lsm_mount_context(&self) -> bool { - self.lsm_mount_context.is_some() - } - - // Param is passed by value, moved - pub fn set_lsm_mount_context(&mut self, v: ::std::string::String) { - self.lsm_mount_context = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_lsm_mount_context(&mut self) -> &mut ::std::string::String { - if self.lsm_mount_context.is_none() { - self.lsm_mount_context.set_default(); - } - self.lsm_mount_context.as_mut().unwrap() - } - - // Take field - pub fn take_lsm_mount_context(&mut self) -> ::std::string::String { - self.lsm_mount_context.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for criu_opts { - fn is_initialized(&self) -> bool { - if self.images_dir_fd.is_none() { - return false; - } - for v in &self.ps { - if !v.is_initialized() { - return false; - } - }; - for v in &self.veths { - if !v.is_initialized() { - return false; - } - }; - for v in &self.ext_mnt { - if !v.is_initialized() { - return false; - } - }; - for v in &self.cg_root { - if !v.is_initialized() { - return false; - } - }; - for v in &self.inherit_fd { - if !v.is_initialized() { - return false; - } - }; - for v in &self.unix_sk_ino { - if !v.is_initialized() { - return false; - } - }; - for v in &self.join_ns { - if !v.is_initialized() { - return false; - } - }; - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.images_dir_fd = ::std::option::Option::Some(tmp); - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.pid = ::std::option::Option::Some(tmp); - }, - 3 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.leave_running = ::std::option::Option::Some(tmp); - }, - 4 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.ext_unix_sk = ::std::option::Option::Some(tmp); - }, - 5 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.tcp_established = ::std::option::Option::Some(tmp); - }, - 6 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.evasive_devices = ::std::option::Option::Some(tmp); - }, - 7 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.shell_job = ::std::option::Option::Some(tmp); - }, - 8 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.file_locks = ::std::option::Option::Some(tmp); - }, - 9 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.log_level = ::std::option::Option::Some(tmp); - }, - 10 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.log_file)?; - }, - 11 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ps)?; - }, - 12 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.notify_scripts = ::std::option::Option::Some(tmp); - }, - 13 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.root)?; - }, - 14 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.parent_img)?; - }, - 15 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.track_mem = ::std::option::Option::Some(tmp); - }, - 16 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.auto_dedup = ::std::option::Option::Some(tmp); - }, - 17 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.work_dir_fd = ::std::option::Option::Some(tmp); - }, - 18 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.link_remap = ::std::option::Option::Some(tmp); - }, - 19 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.veths)?; - }, - 20 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.cpu_cap = ::std::option::Option::Some(tmp); - }, - 21 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.force_irmap = ::std::option::Option::Some(tmp); - }, - 22 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.exec_cmd)?; - }, - 23 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.ext_mnt)?; - }, - 24 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.manage_cgroups = ::std::option::Option::Some(tmp); - }, - 25 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.cg_root)?; - }, - 26 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.rst_sibling = ::std::option::Option::Some(tmp); - }, - 27 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.inherit_fd)?; - }, - 28 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.auto_ext_mnt = ::std::option::Option::Some(tmp); - }, - 29 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.ext_sharing = ::std::option::Option::Some(tmp); - }, - 30 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.ext_masters = ::std::option::Option::Some(tmp); - }, - 31 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.skip_mnt)?; - }, - 32 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.enable_fs)?; - }, - 33 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.unix_sk_ino)?; - }, - 34 => { - ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.manage_cgroups_mode, 34, &mut self.unknown_fields)? - }, - 35 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.ghost_limit = ::std::option::Option::Some(tmp); - }, - 36 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.irmap_scan_paths)?; - }, - 37 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.external)?; - }, - 38 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.empty_ns = ::std::option::Option::Some(tmp); - }, - 39 => { - ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.join_ns)?; - }, - 41 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cgroup_props)?; - }, - 42 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cgroup_props_file)?; - }, - 43 => { - ::protobuf::rt::read_repeated_string_into(wire_type, is, &mut self.cgroup_dump_controller)?; - }, - 44 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.freeze_cgroup)?; - }, - 45 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.timeout = ::std::option::Option::Some(tmp); - }, - 46 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.tcp_skip_in_flight = ::std::option::Option::Some(tmp); - }, - 47 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.weak_sysctls = ::std::option::Option::Some(tmp); - }, - 48 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.lazy_pages = ::std::option::Option::Some(tmp); - }, - 49 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.status_fd = ::std::option::Option::Some(tmp); - }, - 50 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.orphan_pts_master = ::std::option::Option::Some(tmp); - }, - 51 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.config_file)?; - }, - 52 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.tcp_close = ::std::option::Option::Some(tmp); - }, - 53 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.lsm_profile)?; - }, - 54 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.tls_cacert)?; - }, - 55 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.tls_cacrl)?; - }, - 56 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.tls_cert)?; - }, - 57 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.tls_key)?; - }, - 58 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.tls = ::std::option::Option::Some(tmp); - }, - 59 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.tls_no_cn_verify = ::std::option::Option::Some(tmp); - }, - 60 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cgroup_yard)?; - }, - 61 => { - ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.pre_dump_mode, 61, &mut self.unknown_fields)? - }, - 62 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.pidfd_store_sk = ::std::option::Option::Some(tmp); - }, - 63 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.lsm_mount_context)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.images_dir_fd { - my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.pid { - my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.leave_running { - my_size += 2; - } - if let Some(v) = self.ext_unix_sk { - my_size += 2; - } - if let Some(v) = self.tcp_established { - my_size += 2; - } - if let Some(v) = self.evasive_devices { - my_size += 2; - } - if let Some(v) = self.shell_job { - my_size += 2; - } - if let Some(v) = self.file_locks { - my_size += 2; - } - if let Some(v) = self.log_level { - my_size += ::protobuf::rt::value_size(9, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(ref v) = self.log_file.as_ref() { - my_size += ::protobuf::rt::string_size(10, &v); - } - if let Some(ref v) = self.ps.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(v) = self.notify_scripts { - my_size += 2; - } - if let Some(ref v) = self.root.as_ref() { - my_size += ::protobuf::rt::string_size(13, &v); - } - if let Some(ref v) = self.parent_img.as_ref() { - my_size += ::protobuf::rt::string_size(14, &v); - } - if let Some(v) = self.track_mem { - my_size += 2; - } - if let Some(v) = self.auto_dedup { - my_size += 3; - } - if let Some(v) = self.work_dir_fd { - my_size += ::protobuf::rt::value_size(17, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.link_remap { - my_size += 3; - } - for value in &self.veths { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(v) = self.cpu_cap { - my_size += ::protobuf::rt::value_size(20, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.force_irmap { - my_size += 3; - } - for value in &self.exec_cmd { - my_size += ::protobuf::rt::string_size(22, &value); - }; - for value in &self.ext_mnt { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(v) = self.manage_cgroups { - my_size += 3; - } - for value in &self.cg_root { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(v) = self.rst_sibling { - my_size += 3; - } - for value in &self.inherit_fd { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(v) = self.auto_ext_mnt { - my_size += 3; - } - if let Some(v) = self.ext_sharing { - my_size += 3; - } - if let Some(v) = self.ext_masters { - my_size += 3; - } - for value in &self.skip_mnt { - my_size += ::protobuf::rt::string_size(31, &value); - }; - for value in &self.enable_fs { - my_size += ::protobuf::rt::string_size(32, &value); - }; - for value in &self.unix_sk_ino { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(v) = self.manage_cgroups_mode { - my_size += ::protobuf::rt::enum_size(34, v); - } - if let Some(v) = self.ghost_limit { - my_size += ::protobuf::rt::value_size(35, v, ::protobuf::wire_format::WireTypeVarint); - } - for value in &self.irmap_scan_paths { - my_size += ::protobuf::rt::string_size(36, &value); - }; - for value in &self.external { - my_size += ::protobuf::rt::string_size(37, &value); - }; - if let Some(v) = self.empty_ns { - my_size += ::protobuf::rt::value_size(38, v, ::protobuf::wire_format::WireTypeVarint); - } - for value in &self.join_ns { - let len = value.compute_size(); - my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - }; - if let Some(ref v) = self.cgroup_props.as_ref() { - my_size += ::protobuf::rt::string_size(41, &v); - } - if let Some(ref v) = self.cgroup_props_file.as_ref() { - my_size += ::protobuf::rt::string_size(42, &v); - } - for value in &self.cgroup_dump_controller { - my_size += ::protobuf::rt::string_size(43, &value); - }; - if let Some(ref v) = self.freeze_cgroup.as_ref() { - my_size += ::protobuf::rt::string_size(44, &v); - } - if let Some(v) = self.timeout { - my_size += ::protobuf::rt::value_size(45, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.tcp_skip_in_flight { - my_size += 3; - } - if let Some(v) = self.weak_sysctls { - my_size += 3; - } - if let Some(v) = self.lazy_pages { - my_size += 3; - } - if let Some(v) = self.status_fd { - my_size += ::protobuf::rt::value_size(49, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.orphan_pts_master { - my_size += 3; - } - if let Some(ref v) = self.config_file.as_ref() { - my_size += ::protobuf::rt::string_size(51, &v); - } - if let Some(v) = self.tcp_close { - my_size += 3; - } - if let Some(ref v) = self.lsm_profile.as_ref() { - my_size += ::protobuf::rt::string_size(53, &v); - } - if let Some(ref v) = self.tls_cacert.as_ref() { - my_size += ::protobuf::rt::string_size(54, &v); - } - if let Some(ref v) = self.tls_cacrl.as_ref() { - my_size += ::protobuf::rt::string_size(55, &v); - } - if let Some(ref v) = self.tls_cert.as_ref() { - my_size += ::protobuf::rt::string_size(56, &v); - } - if let Some(ref v) = self.tls_key.as_ref() { - my_size += ::protobuf::rt::string_size(57, &v); - } - if let Some(v) = self.tls { - my_size += 3; - } - if let Some(v) = self.tls_no_cn_verify { - my_size += 3; - } - if let Some(ref v) = self.cgroup_yard.as_ref() { - my_size += ::protobuf::rt::string_size(60, &v); - } - if let Some(v) = self.pre_dump_mode { - my_size += ::protobuf::rt::enum_size(61, v); - } - if let Some(v) = self.pidfd_store_sk { - my_size += ::protobuf::rt::value_size(62, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(ref v) = self.lsm_mount_context.as_ref() { - my_size += ::protobuf::rt::string_size(63, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.images_dir_fd { - os.write_int32(1, v)?; - } - if let Some(v) = self.pid { - os.write_int32(2, v)?; - } - if let Some(v) = self.leave_running { - os.write_bool(3, v)?; - } - if let Some(v) = self.ext_unix_sk { - os.write_bool(4, v)?; - } - if let Some(v) = self.tcp_established { - os.write_bool(5, v)?; - } - if let Some(v) = self.evasive_devices { - os.write_bool(6, v)?; - } - if let Some(v) = self.shell_job { - os.write_bool(7, v)?; - } - if let Some(v) = self.file_locks { - os.write_bool(8, v)?; - } - if let Some(v) = self.log_level { - os.write_int32(9, v)?; - } - if let Some(ref v) = self.log_file.as_ref() { - os.write_string(10, &v)?; - } - if let Some(ref v) = self.ps.as_ref() { - os.write_tag(11, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(v) = self.notify_scripts { - os.write_bool(12, v)?; - } - if let Some(ref v) = self.root.as_ref() { - os.write_string(13, &v)?; - } - if let Some(ref v) = self.parent_img.as_ref() { - os.write_string(14, &v)?; - } - if let Some(v) = self.track_mem { - os.write_bool(15, v)?; - } - if let Some(v) = self.auto_dedup { - os.write_bool(16, v)?; - } - if let Some(v) = self.work_dir_fd { - os.write_int32(17, v)?; - } - if let Some(v) = self.link_remap { - os.write_bool(18, v)?; - } - for v in &self.veths { - os.write_tag(19, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(v) = self.cpu_cap { - os.write_uint32(20, v)?; - } - if let Some(v) = self.force_irmap { - os.write_bool(21, v)?; - } - for v in &self.exec_cmd { - os.write_string(22, &v)?; - }; - for v in &self.ext_mnt { - os.write_tag(23, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(v) = self.manage_cgroups { - os.write_bool(24, v)?; - } - for v in &self.cg_root { - os.write_tag(25, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(v) = self.rst_sibling { - os.write_bool(26, v)?; - } - for v in &self.inherit_fd { - os.write_tag(27, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(v) = self.auto_ext_mnt { - os.write_bool(28, v)?; - } - if let Some(v) = self.ext_sharing { - os.write_bool(29, v)?; - } - if let Some(v) = self.ext_masters { - os.write_bool(30, v)?; - } - for v in &self.skip_mnt { - os.write_string(31, &v)?; - }; - for v in &self.enable_fs { - os.write_string(32, &v)?; - }; - for v in &self.unix_sk_ino { - os.write_tag(33, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(v) = self.manage_cgroups_mode { - os.write_enum(34, ::protobuf::ProtobufEnum::value(&v))?; - } - if let Some(v) = self.ghost_limit { - os.write_uint32(35, v)?; - } - for v in &self.irmap_scan_paths { - os.write_string(36, &v)?; - }; - for v in &self.external { - os.write_string(37, &v)?; - }; - if let Some(v) = self.empty_ns { - os.write_uint32(38, v)?; - } - for v in &self.join_ns { - os.write_tag(39, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - }; - if let Some(ref v) = self.cgroup_props.as_ref() { - os.write_string(41, &v)?; - } - if let Some(ref v) = self.cgroup_props_file.as_ref() { - os.write_string(42, &v)?; - } - for v in &self.cgroup_dump_controller { - os.write_string(43, &v)?; - }; - if let Some(ref v) = self.freeze_cgroup.as_ref() { - os.write_string(44, &v)?; - } - if let Some(v) = self.timeout { - os.write_uint32(45, v)?; - } - if let Some(v) = self.tcp_skip_in_flight { - os.write_bool(46, v)?; - } - if let Some(v) = self.weak_sysctls { - os.write_bool(47, v)?; - } - if let Some(v) = self.lazy_pages { - os.write_bool(48, v)?; - } - if let Some(v) = self.status_fd { - os.write_int32(49, v)?; - } - if let Some(v) = self.orphan_pts_master { - os.write_bool(50, v)?; - } - if let Some(ref v) = self.config_file.as_ref() { - os.write_string(51, &v)?; - } - if let Some(v) = self.tcp_close { - os.write_bool(52, v)?; - } - if let Some(ref v) = self.lsm_profile.as_ref() { - os.write_string(53, &v)?; - } - if let Some(ref v) = self.tls_cacert.as_ref() { - os.write_string(54, &v)?; - } - if let Some(ref v) = self.tls_cacrl.as_ref() { - os.write_string(55, &v)?; - } - if let Some(ref v) = self.tls_cert.as_ref() { - os.write_string(56, &v)?; - } - if let Some(ref v) = self.tls_key.as_ref() { - os.write_string(57, &v)?; - } - if let Some(v) = self.tls { - os.write_bool(58, v)?; - } - if let Some(v) = self.tls_no_cn_verify { - os.write_bool(59, v)?; - } - if let Some(ref v) = self.cgroup_yard.as_ref() { - os.write_string(60, &v)?; - } - if let Some(v) = self.pre_dump_mode { - os.write_enum(61, ::protobuf::ProtobufEnum::value(&v))?; - } - if let Some(v) = self.pidfd_store_sk { - os.write_int32(62, v)?; - } - if let Some(ref v) = self.lsm_mount_context.as_ref() { - os.write_string(63, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_opts { - criu_opts::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "images_dir_fd", - |m: &criu_opts| { &m.images_dir_fd }, - |m: &mut criu_opts| { &mut m.images_dir_fd }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "pid", - |m: &criu_opts| { &m.pid }, - |m: &mut criu_opts| { &mut m.pid }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "leave_running", - |m: &criu_opts| { &m.leave_running }, - |m: &mut criu_opts| { &mut m.leave_running }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "ext_unix_sk", - |m: &criu_opts| { &m.ext_unix_sk }, - |m: &mut criu_opts| { &mut m.ext_unix_sk }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "tcp_established", - |m: &criu_opts| { &m.tcp_established }, - |m: &mut criu_opts| { &mut m.tcp_established }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "evasive_devices", - |m: &criu_opts| { &m.evasive_devices }, - |m: &mut criu_opts| { &mut m.evasive_devices }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "shell_job", - |m: &criu_opts| { &m.shell_job }, - |m: &mut criu_opts| { &mut m.shell_job }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "file_locks", - |m: &criu_opts| { &m.file_locks }, - |m: &mut criu_opts| { &mut m.file_locks }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "log_level", - |m: &criu_opts| { &m.log_level }, - |m: &mut criu_opts| { &mut m.log_level }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "log_file", - |m: &criu_opts| { &m.log_file }, - |m: &mut criu_opts| { &mut m.log_file }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "ps", - |m: &criu_opts| { &m.ps }, - |m: &mut criu_opts| { &mut m.ps }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "notify_scripts", - |m: &criu_opts| { &m.notify_scripts }, - |m: &mut criu_opts| { &mut m.notify_scripts }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "root", - |m: &criu_opts| { &m.root }, - |m: &mut criu_opts| { &mut m.root }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "parent_img", - |m: &criu_opts| { &m.parent_img }, - |m: &mut criu_opts| { &mut m.parent_img }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "track_mem", - |m: &criu_opts| { &m.track_mem }, - |m: &mut criu_opts| { &mut m.track_mem }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "auto_dedup", - |m: &criu_opts| { &m.auto_dedup }, - |m: &mut criu_opts| { &mut m.auto_dedup }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "work_dir_fd", - |m: &criu_opts| { &m.work_dir_fd }, - |m: &mut criu_opts| { &mut m.work_dir_fd }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "link_remap", - |m: &criu_opts| { &m.link_remap }, - |m: &mut criu_opts| { &mut m.link_remap }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "veths", - |m: &criu_opts| { &m.veths }, - |m: &mut criu_opts| { &mut m.veths }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "cpu_cap", - |m: &criu_opts| { &m.cpu_cap }, - |m: &mut criu_opts| { &mut m.cpu_cap }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "force_irmap", - |m: &criu_opts| { &m.force_irmap }, - |m: &mut criu_opts| { &mut m.force_irmap }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "exec_cmd", - |m: &criu_opts| { &m.exec_cmd }, - |m: &mut criu_opts| { &mut m.exec_cmd }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "ext_mnt", - |m: &criu_opts| { &m.ext_mnt }, - |m: &mut criu_opts| { &mut m.ext_mnt }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "manage_cgroups", - |m: &criu_opts| { &m.manage_cgroups }, - |m: &mut criu_opts| { &mut m.manage_cgroups }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "cg_root", - |m: &criu_opts| { &m.cg_root }, - |m: &mut criu_opts| { &mut m.cg_root }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "rst_sibling", - |m: &criu_opts| { &m.rst_sibling }, - |m: &mut criu_opts| { &mut m.rst_sibling }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "inherit_fd", - |m: &criu_opts| { &m.inherit_fd }, - |m: &mut criu_opts| { &mut m.inherit_fd }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "auto_ext_mnt", - |m: &criu_opts| { &m.auto_ext_mnt }, - |m: &mut criu_opts| { &mut m.auto_ext_mnt }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "ext_sharing", - |m: &criu_opts| { &m.ext_sharing }, - |m: &mut criu_opts| { &mut m.ext_sharing }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "ext_masters", - |m: &criu_opts| { &m.ext_masters }, - |m: &mut criu_opts| { &mut m.ext_masters }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "skip_mnt", - |m: &criu_opts| { &m.skip_mnt }, - |m: &mut criu_opts| { &mut m.skip_mnt }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "enable_fs", - |m: &criu_opts| { &m.enable_fs }, - |m: &mut criu_opts| { &mut m.enable_fs }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "unix_sk_ino", - |m: &criu_opts| { &m.unix_sk_ino }, - |m: &mut criu_opts| { &mut m.unix_sk_ino }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( - "manage_cgroups_mode", - |m: &criu_opts| { &m.manage_cgroups_mode }, - |m: &mut criu_opts| { &mut m.manage_cgroups_mode }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "ghost_limit", - |m: &criu_opts| { &m.ghost_limit }, - |m: &mut criu_opts| { &mut m.ghost_limit }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "irmap_scan_paths", - |m: &criu_opts| { &m.irmap_scan_paths }, - |m: &mut criu_opts| { &mut m.irmap_scan_paths }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "external", - |m: &criu_opts| { &m.external }, - |m: &mut criu_opts| { &mut m.external }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "empty_ns", - |m: &criu_opts| { &m.empty_ns }, - |m: &mut criu_opts| { &mut m.empty_ns }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "join_ns", - |m: &criu_opts| { &m.join_ns }, - |m: &mut criu_opts| { &mut m.join_ns }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "cgroup_props", - |m: &criu_opts| { &m.cgroup_props }, - |m: &mut criu_opts| { &mut m.cgroup_props }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "cgroup_props_file", - |m: &criu_opts| { &m.cgroup_props_file }, - |m: &mut criu_opts| { &mut m.cgroup_props_file }, - )); - fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "cgroup_dump_controller", - |m: &criu_opts| { &m.cgroup_dump_controller }, - |m: &mut criu_opts| { &mut m.cgroup_dump_controller }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "freeze_cgroup", - |m: &criu_opts| { &m.freeze_cgroup }, - |m: &mut criu_opts| { &mut m.freeze_cgroup }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "timeout", - |m: &criu_opts| { &m.timeout }, - |m: &mut criu_opts| { &mut m.timeout }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "tcp_skip_in_flight", - |m: &criu_opts| { &m.tcp_skip_in_flight }, - |m: &mut criu_opts| { &mut m.tcp_skip_in_flight }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "weak_sysctls", - |m: &criu_opts| { &m.weak_sysctls }, - |m: &mut criu_opts| { &mut m.weak_sysctls }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "lazy_pages", - |m: &criu_opts| { &m.lazy_pages }, - |m: &mut criu_opts| { &mut m.lazy_pages }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "status_fd", - |m: &criu_opts| { &m.status_fd }, - |m: &mut criu_opts| { &mut m.status_fd }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "orphan_pts_master", - |m: &criu_opts| { &m.orphan_pts_master }, - |m: &mut criu_opts| { &mut m.orphan_pts_master }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "config_file", - |m: &criu_opts| { &m.config_file }, - |m: &mut criu_opts| { &mut m.config_file }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "tcp_close", - |m: &criu_opts| { &m.tcp_close }, - |m: &mut criu_opts| { &mut m.tcp_close }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "lsm_profile", - |m: &criu_opts| { &m.lsm_profile }, - |m: &mut criu_opts| { &mut m.lsm_profile }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "tls_cacert", - |m: &criu_opts| { &m.tls_cacert }, - |m: &mut criu_opts| { &mut m.tls_cacert }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "tls_cacrl", - |m: &criu_opts| { &m.tls_cacrl }, - |m: &mut criu_opts| { &mut m.tls_cacrl }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "tls_cert", - |m: &criu_opts| { &m.tls_cert }, - |m: &mut criu_opts| { &mut m.tls_cert }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "tls_key", - |m: &criu_opts| { &m.tls_key }, - |m: &mut criu_opts| { &mut m.tls_key }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "tls", - |m: &criu_opts| { &m.tls }, - |m: &mut criu_opts| { &mut m.tls }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "tls_no_cn_verify", - |m: &criu_opts| { &m.tls_no_cn_verify }, - |m: &mut criu_opts| { &mut m.tls_no_cn_verify }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "cgroup_yard", - |m: &criu_opts| { &m.cgroup_yard }, - |m: &mut criu_opts| { &mut m.cgroup_yard }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( - "pre_dump_mode", - |m: &criu_opts| { &m.pre_dump_mode }, - |m: &mut criu_opts| { &mut m.pre_dump_mode }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "pidfd_store_sk", - |m: &criu_opts| { &m.pidfd_store_sk }, - |m: &mut criu_opts| { &mut m.pidfd_store_sk }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "lsm_mount_context", - |m: &criu_opts| { &m.lsm_mount_context }, - |m: &mut criu_opts| { &mut m.lsm_mount_context }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_opts", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_opts { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_opts::new) - } -} - -impl ::protobuf::Clear for criu_opts { - fn clear(&mut self) { - self.images_dir_fd = ::std::option::Option::None; - self.pid = ::std::option::Option::None; - self.leave_running = ::std::option::Option::None; - self.ext_unix_sk = ::std::option::Option::None; - self.tcp_established = ::std::option::Option::None; - self.evasive_devices = ::std::option::Option::None; - self.shell_job = ::std::option::Option::None; - self.file_locks = ::std::option::Option::None; - self.log_level = ::std::option::Option::None; - self.log_file.clear(); - self.ps.clear(); - self.notify_scripts = ::std::option::Option::None; - self.root.clear(); - self.parent_img.clear(); - self.track_mem = ::std::option::Option::None; - self.auto_dedup = ::std::option::Option::None; - self.work_dir_fd = ::std::option::Option::None; - self.link_remap = ::std::option::Option::None; - self.veths.clear(); - self.cpu_cap = ::std::option::Option::None; - self.force_irmap = ::std::option::Option::None; - self.exec_cmd.clear(); - self.ext_mnt.clear(); - self.manage_cgroups = ::std::option::Option::None; - self.cg_root.clear(); - self.rst_sibling = ::std::option::Option::None; - self.inherit_fd.clear(); - self.auto_ext_mnt = ::std::option::Option::None; - self.ext_sharing = ::std::option::Option::None; - self.ext_masters = ::std::option::Option::None; - self.skip_mnt.clear(); - self.enable_fs.clear(); - self.unix_sk_ino.clear(); - self.manage_cgroups_mode = ::std::option::Option::None; - self.ghost_limit = ::std::option::Option::None; - self.irmap_scan_paths.clear(); - self.external.clear(); - self.empty_ns = ::std::option::Option::None; - self.join_ns.clear(); - self.cgroup_props.clear(); - self.cgroup_props_file.clear(); - self.cgroup_dump_controller.clear(); - self.freeze_cgroup.clear(); - self.timeout = ::std::option::Option::None; - self.tcp_skip_in_flight = ::std::option::Option::None; - self.weak_sysctls = ::std::option::Option::None; - self.lazy_pages = ::std::option::Option::None; - self.status_fd = ::std::option::Option::None; - self.orphan_pts_master = ::std::option::Option::None; - self.config_file.clear(); - self.tcp_close = ::std::option::Option::None; - self.lsm_profile.clear(); - self.tls_cacert.clear(); - self.tls_cacrl.clear(); - self.tls_cert.clear(); - self.tls_key.clear(); - self.tls = ::std::option::Option::None; - self.tls_no_cn_verify = ::std::option::Option::None; - self.cgroup_yard.clear(); - self.pre_dump_mode = ::std::option::Option::None; - self.pidfd_store_sk = ::std::option::Option::None; - self.lsm_mount_context.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_opts { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_opts { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_dump_resp { - // message fields - restored: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_dump_resp { - fn default() -> &'a criu_dump_resp { - ::default_instance() - } -} - -impl criu_dump_resp { - pub fn new() -> criu_dump_resp { - ::std::default::Default::default() - } - - // optional bool restored = 1; - - - pub fn get_restored(&self) -> bool { - self.restored.unwrap_or(false) - } - pub fn clear_restored(&mut self) { - self.restored = ::std::option::Option::None; - } - - pub fn has_restored(&self) -> bool { - self.restored.is_some() - } - - // Param is passed by value, moved - pub fn set_restored(&mut self, v: bool) { - self.restored = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_dump_resp { - fn is_initialized(&self) -> bool { - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.restored = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.restored { - my_size += 2; - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.restored { - os.write_bool(1, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_dump_resp { - criu_dump_resp::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "restored", - |m: &criu_dump_resp| { &m.restored }, - |m: &mut criu_dump_resp| { &mut m.restored }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_dump_resp", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_dump_resp { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_dump_resp::new) - } -} - -impl ::protobuf::Clear for criu_dump_resp { - fn clear(&mut self) { - self.restored = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_dump_resp { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_dump_resp { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_restore_resp { - // message fields - pid: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_restore_resp { - fn default() -> &'a criu_restore_resp { - ::default_instance() - } -} - -impl criu_restore_resp { - pub fn new() -> criu_restore_resp { - ::std::default::Default::default() - } - - // required int32 pid = 1; - - - pub fn get_pid(&self) -> i32 { - self.pid.unwrap_or(0) - } - pub fn clear_pid(&mut self) { - self.pid = ::std::option::Option::None; - } - - pub fn has_pid(&self) -> bool { - self.pid.is_some() - } - - // Param is passed by value, moved - pub fn set_pid(&mut self, v: i32) { - self.pid = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_restore_resp { - fn is_initialized(&self) -> bool { - if self.pid.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.pid = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.pid { - my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.pid { - os.write_int32(1, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_restore_resp { - criu_restore_resp::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "pid", - |m: &criu_restore_resp| { &m.pid }, - |m: &mut criu_restore_resp| { &mut m.pid }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_restore_resp", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_restore_resp { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_restore_resp::new) - } -} - -impl ::protobuf::Clear for criu_restore_resp { - fn clear(&mut self) { - self.pid = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_restore_resp { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_restore_resp { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_notify { - // message fields - script: ::protobuf::SingularField<::std::string::String>, - pid: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_notify { - fn default() -> &'a criu_notify { - ::default_instance() - } -} - -impl criu_notify { - pub fn new() -> criu_notify { - ::std::default::Default::default() - } - - // optional string script = 1; - - - pub fn get_script(&self) -> &str { - match self.script.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_script(&mut self) { - self.script.clear(); - } - - pub fn has_script(&self) -> bool { - self.script.is_some() - } - - // Param is passed by value, moved - pub fn set_script(&mut self, v: ::std::string::String) { - self.script = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_script(&mut self) -> &mut ::std::string::String { - if self.script.is_none() { - self.script.set_default(); - } - self.script.as_mut().unwrap() - } - - // Take field - pub fn take_script(&mut self) -> ::std::string::String { - self.script.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional int32 pid = 2; - - - pub fn get_pid(&self) -> i32 { - self.pid.unwrap_or(0) - } - pub fn clear_pid(&mut self) { - self.pid = ::std::option::Option::None; - } - - pub fn has_pid(&self) -> bool { - self.pid.is_some() - } - - // Param is passed by value, moved - pub fn set_pid(&mut self, v: i32) { - self.pid = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_notify { - fn is_initialized(&self) -> bool { - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.script)?; - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.pid = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(ref v) = self.script.as_ref() { - my_size += ::protobuf::rt::string_size(1, &v); - } - if let Some(v) = self.pid { - my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(ref v) = self.script.as_ref() { - os.write_string(1, &v)?; - } - if let Some(v) = self.pid { - os.write_int32(2, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_notify { - criu_notify::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "script", - |m: &criu_notify| { &m.script }, - |m: &mut criu_notify| { &mut m.script }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "pid", - |m: &criu_notify| { &m.pid }, - |m: &mut criu_notify| { &mut m.pid }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_notify", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_notify { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_notify::new) - } -} - -impl ::protobuf::Clear for criu_notify { - fn clear(&mut self) { - self.script.clear(); - self.pid = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_notify { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_notify { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_features { - // message fields - mem_track: ::std::option::Option, - lazy_pages: ::std::option::Option, - pidfd_store: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_features { - fn default() -> &'a criu_features { - ::default_instance() - } -} - -impl criu_features { - pub fn new() -> criu_features { - ::std::default::Default::default() - } - - // optional bool mem_track = 1; - - - pub fn get_mem_track(&self) -> bool { - self.mem_track.unwrap_or(false) - } - pub fn clear_mem_track(&mut self) { - self.mem_track = ::std::option::Option::None; - } - - pub fn has_mem_track(&self) -> bool { - self.mem_track.is_some() - } - - // Param is passed by value, moved - pub fn set_mem_track(&mut self, v: bool) { - self.mem_track = ::std::option::Option::Some(v); - } - - // optional bool lazy_pages = 2; - - - pub fn get_lazy_pages(&self) -> bool { - self.lazy_pages.unwrap_or(false) - } - pub fn clear_lazy_pages(&mut self) { - self.lazy_pages = ::std::option::Option::None; - } - - pub fn has_lazy_pages(&self) -> bool { - self.lazy_pages.is_some() - } - - // Param is passed by value, moved - pub fn set_lazy_pages(&mut self, v: bool) { - self.lazy_pages = ::std::option::Option::Some(v); - } - - // optional bool pidfd_store = 3; - - - pub fn get_pidfd_store(&self) -> bool { - self.pidfd_store.unwrap_or(false) - } - pub fn clear_pidfd_store(&mut self) { - self.pidfd_store = ::std::option::Option::None; - } - - pub fn has_pidfd_store(&self) -> bool { - self.pidfd_store.is_some() - } - - // Param is passed by value, moved - pub fn set_pidfd_store(&mut self, v: bool) { - self.pidfd_store = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_features { - fn is_initialized(&self) -> bool { - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.mem_track = ::std::option::Option::Some(tmp); - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.lazy_pages = ::std::option::Option::Some(tmp); - }, - 3 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.pidfd_store = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.mem_track { - my_size += 2; - } - if let Some(v) = self.lazy_pages { - my_size += 2; - } - if let Some(v) = self.pidfd_store { - my_size += 2; - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.mem_track { - os.write_bool(1, v)?; - } - if let Some(v) = self.lazy_pages { - os.write_bool(2, v)?; - } - if let Some(v) = self.pidfd_store { - os.write_bool(3, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_features { - criu_features::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "mem_track", - |m: &criu_features| { &m.mem_track }, - |m: &mut criu_features| { &mut m.mem_track }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "lazy_pages", - |m: &criu_features| { &m.lazy_pages }, - |m: &mut criu_features| { &mut m.lazy_pages }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "pidfd_store", - |m: &criu_features| { &m.pidfd_store }, - |m: &mut criu_features| { &mut m.pidfd_store }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_features", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_features { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_features::new) - } -} - -impl ::protobuf::Clear for criu_features { - fn clear(&mut self) { - self.mem_track = ::std::option::Option::None; - self.lazy_pages = ::std::option::Option::None; - self.pidfd_store = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_features { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_features { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_req { - // message fields - field_type: ::std::option::Option, - pub opts: ::protobuf::SingularPtrField, - notify_success: ::std::option::Option, - keep_open: ::std::option::Option, - pub features: ::protobuf::SingularPtrField, - pid: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_req { - fn default() -> &'a criu_req { - ::default_instance() - } -} - -impl criu_req { - pub fn new() -> criu_req { - ::std::default::Default::default() - } - - // required .criu_req_type type = 1; - - - pub fn get_field_type(&self) -> criu_req_type { - self.field_type.unwrap_or(criu_req_type::EMPTY) - } - pub fn clear_field_type(&mut self) { - self.field_type = ::std::option::Option::None; - } - - pub fn has_field_type(&self) -> bool { - self.field_type.is_some() - } - - // Param is passed by value, moved - pub fn set_field_type(&mut self, v: criu_req_type) { - self.field_type = ::std::option::Option::Some(v); - } - - // optional .criu_opts opts = 2; - - - pub fn get_opts(&self) -> &criu_opts { - self.opts.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_opts(&mut self) { - self.opts.clear(); - } - - pub fn has_opts(&self) -> bool { - self.opts.is_some() - } - - // Param is passed by value, moved - pub fn set_opts(&mut self, v: criu_opts) { - self.opts = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_opts(&mut self) -> &mut criu_opts { - if self.opts.is_none() { - self.opts.set_default(); - } - self.opts.as_mut().unwrap() - } - - // Take field - pub fn take_opts(&mut self) -> criu_opts { - self.opts.take().unwrap_or_else(|| criu_opts::new()) - } - - // optional bool notify_success = 3; - - - pub fn get_notify_success(&self) -> bool { - self.notify_success.unwrap_or(false) - } - pub fn clear_notify_success(&mut self) { - self.notify_success = ::std::option::Option::None; - } - - pub fn has_notify_success(&self) -> bool { - self.notify_success.is_some() - } - - // Param is passed by value, moved - pub fn set_notify_success(&mut self, v: bool) { - self.notify_success = ::std::option::Option::Some(v); - } - - // optional bool keep_open = 4; - - - pub fn get_keep_open(&self) -> bool { - self.keep_open.unwrap_or(false) - } - pub fn clear_keep_open(&mut self) { - self.keep_open = ::std::option::Option::None; - } - - pub fn has_keep_open(&self) -> bool { - self.keep_open.is_some() - } - - // Param is passed by value, moved - pub fn set_keep_open(&mut self, v: bool) { - self.keep_open = ::std::option::Option::Some(v); - } - - // optional .criu_features features = 5; - - - pub fn get_features(&self) -> &criu_features { - self.features.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_features(&mut self) { - self.features.clear(); - } - - pub fn has_features(&self) -> bool { - self.features.is_some() - } - - // Param is passed by value, moved - pub fn set_features(&mut self, v: criu_features) { - self.features = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_features(&mut self) -> &mut criu_features { - if self.features.is_none() { - self.features.set_default(); - } - self.features.as_mut().unwrap() - } - - // Take field - pub fn take_features(&mut self) -> criu_features { - self.features.take().unwrap_or_else(|| criu_features::new()) - } - - // optional uint32 pid = 6; - - - pub fn get_pid(&self) -> u32 { - self.pid.unwrap_or(0) - } - pub fn clear_pid(&mut self) { - self.pid = ::std::option::Option::None; - } - - pub fn has_pid(&self) -> bool { - self.pid.is_some() - } - - // Param is passed by value, moved - pub fn set_pid(&mut self, v: u32) { - self.pid = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_req { - fn is_initialized(&self) -> bool { - if self.field_type.is_none() { - return false; - } - for v in &self.opts { - if !v.is_initialized() { - return false; - } - }; - for v in &self.features { - if !v.is_initialized() { - return false; - } - }; - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 1, &mut self.unknown_fields)? - }, - 2 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.opts)?; - }, - 3 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.notify_success = ::std::option::Option::Some(tmp); - }, - 4 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.keep_open = ::std::option::Option::Some(tmp); - }, - 5 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.features)?; - }, - 6 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_uint32()?; - self.pid = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.field_type { - my_size += ::protobuf::rt::enum_size(1, v); - } - if let Some(ref v) = self.opts.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(v) = self.notify_success { - my_size += 2; - } - if let Some(v) = self.keep_open { - my_size += 2; - } - if let Some(ref v) = self.features.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(v) = self.pid { - my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.field_type { - os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?; - } - if let Some(ref v) = self.opts.as_ref() { - os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(v) = self.notify_success { - os.write_bool(3, v)?; - } - if let Some(v) = self.keep_open { - os.write_bool(4, v)?; - } - if let Some(ref v) = self.features.as_ref() { - os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(v) = self.pid { - os.write_uint32(6, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_req { - criu_req::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( - "type", - |m: &criu_req| { &m.field_type }, - |m: &mut criu_req| { &mut m.field_type }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "opts", - |m: &criu_req| { &m.opts }, - |m: &mut criu_req| { &mut m.opts }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "notify_success", - |m: &criu_req| { &m.notify_success }, - |m: &mut criu_req| { &mut m.notify_success }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "keep_open", - |m: &criu_req| { &m.keep_open }, - |m: &mut criu_req| { &mut m.keep_open }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "features", - |m: &criu_req| { &m.features }, - |m: &mut criu_req| { &mut m.features }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( - "pid", - |m: &criu_req| { &m.pid }, - |m: &mut criu_req| { &mut m.pid }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_req", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_req { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_req::new) - } -} - -impl ::protobuf::Clear for criu_req { - fn clear(&mut self) { - self.field_type = ::std::option::Option::None; - self.opts.clear(); - self.notify_success = ::std::option::Option::None; - self.keep_open = ::std::option::Option::None; - self.features.clear(); - self.pid = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_req { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_req { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_resp { - // message fields - field_type: ::std::option::Option, - success: ::std::option::Option, - pub dump: ::protobuf::SingularPtrField, - pub restore: ::protobuf::SingularPtrField, - pub notify: ::protobuf::SingularPtrField, - pub ps: ::protobuf::SingularPtrField, - cr_errno: ::std::option::Option, - pub features: ::protobuf::SingularPtrField, - cr_errmsg: ::protobuf::SingularField<::std::string::String>, - pub version: ::protobuf::SingularPtrField, - status: ::std::option::Option, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_resp { - fn default() -> &'a criu_resp { - ::default_instance() - } -} - -impl criu_resp { - pub fn new() -> criu_resp { - ::std::default::Default::default() - } - - // required .criu_req_type type = 1; - - - pub fn get_field_type(&self) -> criu_req_type { - self.field_type.unwrap_or(criu_req_type::EMPTY) - } - pub fn clear_field_type(&mut self) { - self.field_type = ::std::option::Option::None; - } - - pub fn has_field_type(&self) -> bool { - self.field_type.is_some() - } - - // Param is passed by value, moved - pub fn set_field_type(&mut self, v: criu_req_type) { - self.field_type = ::std::option::Option::Some(v); - } - - // required bool success = 2; - - - pub fn get_success(&self) -> bool { - self.success.unwrap_or(false) - } - pub fn clear_success(&mut self) { - self.success = ::std::option::Option::None; - } - - pub fn has_success(&self) -> bool { - self.success.is_some() - } - - // Param is passed by value, moved - pub fn set_success(&mut self, v: bool) { - self.success = ::std::option::Option::Some(v); - } - - // optional .criu_dump_resp dump = 3; - - - pub fn get_dump(&self) -> &criu_dump_resp { - self.dump.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_dump(&mut self) { - self.dump.clear(); - } - - pub fn has_dump(&self) -> bool { - self.dump.is_some() - } - - // Param is passed by value, moved - pub fn set_dump(&mut self, v: criu_dump_resp) { - self.dump = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_dump(&mut self) -> &mut criu_dump_resp { - if self.dump.is_none() { - self.dump.set_default(); - } - self.dump.as_mut().unwrap() - } - - // Take field - pub fn take_dump(&mut self) -> criu_dump_resp { - self.dump.take().unwrap_or_else(|| criu_dump_resp::new()) - } - - // optional .criu_restore_resp restore = 4; - - - pub fn get_restore(&self) -> &criu_restore_resp { - self.restore.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_restore(&mut self) { - self.restore.clear(); - } - - pub fn has_restore(&self) -> bool { - self.restore.is_some() - } - - // Param is passed by value, moved - pub fn set_restore(&mut self, v: criu_restore_resp) { - self.restore = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_restore(&mut self) -> &mut criu_restore_resp { - if self.restore.is_none() { - self.restore.set_default(); - } - self.restore.as_mut().unwrap() - } - - // Take field - pub fn take_restore(&mut self) -> criu_restore_resp { - self.restore.take().unwrap_or_else(|| criu_restore_resp::new()) - } - - // optional .criu_notify notify = 5; - - - pub fn get_notify(&self) -> &criu_notify { - self.notify.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_notify(&mut self) { - self.notify.clear(); - } - - pub fn has_notify(&self) -> bool { - self.notify.is_some() - } - - // Param is passed by value, moved - pub fn set_notify(&mut self, v: criu_notify) { - self.notify = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_notify(&mut self) -> &mut criu_notify { - if self.notify.is_none() { - self.notify.set_default(); - } - self.notify.as_mut().unwrap() - } - - // Take field - pub fn take_notify(&mut self) -> criu_notify { - self.notify.take().unwrap_or_else(|| criu_notify::new()) - } - - // optional .criu_page_server_info ps = 6; - - - pub fn get_ps(&self) -> &criu_page_server_info { - self.ps.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_ps(&mut self) { - self.ps.clear(); - } - - pub fn has_ps(&self) -> bool { - self.ps.is_some() - } - - // Param is passed by value, moved - pub fn set_ps(&mut self, v: criu_page_server_info) { - self.ps = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_ps(&mut self) -> &mut criu_page_server_info { - if self.ps.is_none() { - self.ps.set_default(); - } - self.ps.as_mut().unwrap() - } - - // Take field - pub fn take_ps(&mut self) -> criu_page_server_info { - self.ps.take().unwrap_or_else(|| criu_page_server_info::new()) - } - - // optional int32 cr_errno = 7; - - - pub fn get_cr_errno(&self) -> i32 { - self.cr_errno.unwrap_or(0) - } - pub fn clear_cr_errno(&mut self) { - self.cr_errno = ::std::option::Option::None; - } - - pub fn has_cr_errno(&self) -> bool { - self.cr_errno.is_some() - } - - // Param is passed by value, moved - pub fn set_cr_errno(&mut self, v: i32) { - self.cr_errno = ::std::option::Option::Some(v); - } - - // optional .criu_features features = 8; - - - pub fn get_features(&self) -> &criu_features { - self.features.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_features(&mut self) { - self.features.clear(); - } - - pub fn has_features(&self) -> bool { - self.features.is_some() - } - - // Param is passed by value, moved - pub fn set_features(&mut self, v: criu_features) { - self.features = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_features(&mut self) -> &mut criu_features { - if self.features.is_none() { - self.features.set_default(); - } - self.features.as_mut().unwrap() - } - - // Take field - pub fn take_features(&mut self) -> criu_features { - self.features.take().unwrap_or_else(|| criu_features::new()) - } - - // optional string cr_errmsg = 9; - - - pub fn get_cr_errmsg(&self) -> &str { - match self.cr_errmsg.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_cr_errmsg(&mut self) { - self.cr_errmsg.clear(); - } - - pub fn has_cr_errmsg(&self) -> bool { - self.cr_errmsg.is_some() - } - - // Param is passed by value, moved - pub fn set_cr_errmsg(&mut self, v: ::std::string::String) { - self.cr_errmsg = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_cr_errmsg(&mut self) -> &mut ::std::string::String { - if self.cr_errmsg.is_none() { - self.cr_errmsg.set_default(); - } - self.cr_errmsg.as_mut().unwrap() - } - - // Take field - pub fn take_cr_errmsg(&mut self) -> ::std::string::String { - self.cr_errmsg.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional .criu_version version = 10; - - - pub fn get_version(&self) -> &criu_version { - self.version.as_ref().unwrap_or_else(|| ::default_instance()) - } - pub fn clear_version(&mut self) { - self.version.clear(); - } - - pub fn has_version(&self) -> bool { - self.version.is_some() - } - - // Param is passed by value, moved - pub fn set_version(&mut self, v: criu_version) { - self.version = ::protobuf::SingularPtrField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_version(&mut self) -> &mut criu_version { - if self.version.is_none() { - self.version.set_default(); - } - self.version.as_mut().unwrap() - } - - // Take field - pub fn take_version(&mut self) -> criu_version { - self.version.take().unwrap_or_else(|| criu_version::new()) - } - - // optional int32 status = 11; - - - pub fn get_status(&self) -> i32 { - self.status.unwrap_or(0) - } - pub fn clear_status(&mut self) { - self.status = ::std::option::Option::None; - } - - pub fn has_status(&self) -> bool { - self.status.is_some() - } - - // Param is passed by value, moved - pub fn set_status(&mut self, v: i32) { - self.status = ::std::option::Option::Some(v); - } -} - -impl ::protobuf::Message for criu_resp { - fn is_initialized(&self) -> bool { - if self.field_type.is_none() { - return false; - } - if self.success.is_none() { - return false; - } - for v in &self.dump { - if !v.is_initialized() { - return false; - } - }; - for v in &self.restore { - if !v.is_initialized() { - return false; - } - }; - for v in &self.notify { - if !v.is_initialized() { - return false; - } - }; - for v in &self.ps { - if !v.is_initialized() { - return false; - } - }; - for v in &self.features { - if !v.is_initialized() { - return false; - } - }; - for v in &self.version { - if !v.is_initialized() { - return false; - } - }; - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 1, &mut self.unknown_fields)? - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_bool()?; - self.success = ::std::option::Option::Some(tmp); - }, - 3 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.dump)?; - }, - 4 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.restore)?; - }, - 5 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.notify)?; - }, - 6 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.ps)?; - }, - 7 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.cr_errno = ::std::option::Option::Some(tmp); - }, - 8 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.features)?; - }, - 9 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cr_errmsg)?; - }, - 10 => { - ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.version)?; - }, - 11 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.status = ::std::option::Option::Some(tmp); - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.field_type { - my_size += ::protobuf::rt::enum_size(1, v); - } - if let Some(v) = self.success { - my_size += 2; - } - if let Some(ref v) = self.dump.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.restore.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.notify.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.ps.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(v) = self.cr_errno { - my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(ref v) = self.features.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(ref v) = self.cr_errmsg.as_ref() { - my_size += ::protobuf::rt::string_size(9, &v); - } - if let Some(ref v) = self.version.as_ref() { - let len = v.compute_size(); - my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; - } - if let Some(v) = self.status { - my_size += ::protobuf::rt::value_size(11, v, ::protobuf::wire_format::WireTypeVarint); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.field_type { - os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?; - } - if let Some(v) = self.success { - os.write_bool(2, v)?; - } - if let Some(ref v) = self.dump.as_ref() { - os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(ref v) = self.restore.as_ref() { - os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(ref v) = self.notify.as_ref() { - os.write_tag(5, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(ref v) = self.ps.as_ref() { - os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(v) = self.cr_errno { - os.write_int32(7, v)?; - } - if let Some(ref v) = self.features.as_ref() { - os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(ref v) = self.cr_errmsg.as_ref() { - os.write_string(9, &v)?; - } - if let Some(ref v) = self.version.as_ref() { - os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?; - os.write_raw_varint32(v.get_cached_size())?; - v.write_to_with_cached_sizes(os)?; - } - if let Some(v) = self.status { - os.write_int32(11, v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_resp { - criu_resp::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( - "type", - |m: &criu_resp| { &m.field_type }, - |m: &mut criu_resp| { &mut m.field_type }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( - "success", - |m: &criu_resp| { &m.success }, - |m: &mut criu_resp| { &mut m.success }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "dump", - |m: &criu_resp| { &m.dump }, - |m: &mut criu_resp| { &mut m.dump }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "restore", - |m: &criu_resp| { &m.restore }, - |m: &mut criu_resp| { &mut m.restore }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "notify", - |m: &criu_resp| { &m.notify }, - |m: &mut criu_resp| { &mut m.notify }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "ps", - |m: &criu_resp| { &m.ps }, - |m: &mut criu_resp| { &mut m.ps }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "cr_errno", - |m: &criu_resp| { &m.cr_errno }, - |m: &mut criu_resp| { &mut m.cr_errno }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "features", - |m: &criu_resp| { &m.features }, - |m: &mut criu_resp| { &mut m.features }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "cr_errmsg", - |m: &criu_resp| { &m.cr_errmsg }, - |m: &mut criu_resp| { &mut m.cr_errmsg }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( - "version", - |m: &criu_resp| { &m.version }, - |m: &mut criu_resp| { &mut m.version }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "status", - |m: &criu_resp| { &m.status }, - |m: &mut criu_resp| { &mut m.status }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_resp", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_resp { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_resp::new) - } -} - -impl ::protobuf::Clear for criu_resp { - fn clear(&mut self) { - self.field_type = ::std::option::Option::None; - self.success = ::std::option::Option::None; - self.dump.clear(); - self.restore.clear(); - self.notify.clear(); - self.ps.clear(); - self.cr_errno = ::std::option::Option::None; - self.features.clear(); - self.cr_errmsg.clear(); - self.version.clear(); - self.status = ::std::option::Option::None; - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_resp { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_resp { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(PartialEq,Clone,Default)] -pub struct criu_version { - // message fields - major_number: ::std::option::Option, - minor_number: ::std::option::Option, - gitid: ::protobuf::SingularField<::std::string::String>, - sublevel: ::std::option::Option, - extra: ::std::option::Option, - name: ::protobuf::SingularField<::std::string::String>, - // special fields - pub unknown_fields: ::protobuf::UnknownFields, - pub cached_size: ::protobuf::CachedSize, -} - -impl<'a> ::std::default::Default for &'a criu_version { - fn default() -> &'a criu_version { - ::default_instance() - } -} - -impl criu_version { - pub fn new() -> criu_version { - ::std::default::Default::default() - } - - // required int32 major_number = 1; - - - pub fn get_major_number(&self) -> i32 { - self.major_number.unwrap_or(0) - } - pub fn clear_major_number(&mut self) { - self.major_number = ::std::option::Option::None; - } - - pub fn has_major_number(&self) -> bool { - self.major_number.is_some() - } - - // Param is passed by value, moved - pub fn set_major_number(&mut self, v: i32) { - self.major_number = ::std::option::Option::Some(v); - } - - // required int32 minor_number = 2; - - - pub fn get_minor_number(&self) -> i32 { - self.minor_number.unwrap_or(0) - } - pub fn clear_minor_number(&mut self) { - self.minor_number = ::std::option::Option::None; - } - - pub fn has_minor_number(&self) -> bool { - self.minor_number.is_some() - } - - // Param is passed by value, moved - pub fn set_minor_number(&mut self, v: i32) { - self.minor_number = ::std::option::Option::Some(v); - } - - // optional string gitid = 3; - - - pub fn get_gitid(&self) -> &str { - match self.gitid.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_gitid(&mut self) { - self.gitid.clear(); - } - - pub fn has_gitid(&self) -> bool { - self.gitid.is_some() - } - - // Param is passed by value, moved - pub fn set_gitid(&mut self, v: ::std::string::String) { - self.gitid = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_gitid(&mut self) -> &mut ::std::string::String { - if self.gitid.is_none() { - self.gitid.set_default(); - } - self.gitid.as_mut().unwrap() - } - - // Take field - pub fn take_gitid(&mut self) -> ::std::string::String { - self.gitid.take().unwrap_or_else(|| ::std::string::String::new()) - } - - // optional int32 sublevel = 4; - - - pub fn get_sublevel(&self) -> i32 { - self.sublevel.unwrap_or(0) - } - pub fn clear_sublevel(&mut self) { - self.sublevel = ::std::option::Option::None; - } - - pub fn has_sublevel(&self) -> bool { - self.sublevel.is_some() - } - - // Param is passed by value, moved - pub fn set_sublevel(&mut self, v: i32) { - self.sublevel = ::std::option::Option::Some(v); - } - - // optional int32 extra = 5; - - - pub fn get_extra(&self) -> i32 { - self.extra.unwrap_or(0) - } - pub fn clear_extra(&mut self) { - self.extra = ::std::option::Option::None; - } - - pub fn has_extra(&self) -> bool { - self.extra.is_some() - } - - // Param is passed by value, moved - pub fn set_extra(&mut self, v: i32) { - self.extra = ::std::option::Option::Some(v); - } - - // optional string name = 6; - - - pub fn get_name(&self) -> &str { - match self.name.as_ref() { - Some(v) => &v, - None => "", - } - } - pub fn clear_name(&mut self) { - self.name.clear(); - } - - pub fn has_name(&self) -> bool { - self.name.is_some() - } - - // Param is passed by value, moved - pub fn set_name(&mut self, v: ::std::string::String) { - self.name = ::protobuf::SingularField::some(v); - } - - // Mutable pointer to the field. - // If field is not initialized, it is initialized with default value first. - pub fn mut_name(&mut self) -> &mut ::std::string::String { - if self.name.is_none() { - self.name.set_default(); - } - self.name.as_mut().unwrap() - } - - // Take field - pub fn take_name(&mut self) -> ::std::string::String { - self.name.take().unwrap_or_else(|| ::std::string::String::new()) - } -} - -impl ::protobuf::Message for criu_version { - fn is_initialized(&self) -> bool { - if self.major_number.is_none() { - return false; - } - if self.minor_number.is_none() { - return false; - } - true - } - - fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { - while !is.eof()? { - let (field_number, wire_type) = is.read_tag_unpack()?; - match field_number { - 1 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.major_number = ::std::option::Option::Some(tmp); - }, - 2 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.minor_number = ::std::option::Option::Some(tmp); - }, - 3 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.gitid)?; - }, - 4 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.sublevel = ::std::option::Option::Some(tmp); - }, - 5 => { - if wire_type != ::protobuf::wire_format::WireTypeVarint { - return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); - } - let tmp = is.read_int32()?; - self.extra = ::std::option::Option::Some(tmp); - }, - 6 => { - ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; - }, - _ => { - ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; - }, - }; - } - ::std::result::Result::Ok(()) - } - - // Compute sizes of nested messages - #[allow(unused_variables)] - fn compute_size(&self) -> u32 { - let mut my_size = 0; - if let Some(v) = self.major_number { - my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.minor_number { - my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(ref v) = self.gitid.as_ref() { - my_size += ::protobuf::rt::string_size(3, &v); - } - if let Some(v) = self.sublevel { - my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(v) = self.extra { - my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint); - } - if let Some(ref v) = self.name.as_ref() { - my_size += ::protobuf::rt::string_size(6, &v); - } - my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); - self.cached_size.set(my_size); - my_size - } - - fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { - if let Some(v) = self.major_number { - os.write_int32(1, v)?; - } - if let Some(v) = self.minor_number { - os.write_int32(2, v)?; - } - if let Some(ref v) = self.gitid.as_ref() { - os.write_string(3, &v)?; - } - if let Some(v) = self.sublevel { - os.write_int32(4, v)?; - } - if let Some(v) = self.extra { - os.write_int32(5, v)?; - } - if let Some(ref v) = self.name.as_ref() { - os.write_string(6, &v)?; - } - os.write_unknown_fields(self.get_unknown_fields())?; - ::std::result::Result::Ok(()) - } - - fn get_cached_size(&self) -> u32 { - self.cached_size.get() - } - - fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { - &self.unknown_fields - } - - fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { - &mut self.unknown_fields - } - - fn as_any(&self) -> &dyn (::std::any::Any) { - self as &dyn (::std::any::Any) - } - fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { - self as &mut dyn (::std::any::Any) - } - fn into_any(self: ::std::boxed::Box) -> ::std::boxed::Box { - self - } - - fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { - Self::descriptor_static() - } - - fn new() -> criu_version { - criu_version::new() - } - - fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - let mut fields = ::std::vec::Vec::new(); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "major_number", - |m: &criu_version| { &m.major_number }, - |m: &mut criu_version| { &mut m.major_number }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "minor_number", - |m: &criu_version| { &m.minor_number }, - |m: &mut criu_version| { &mut m.minor_number }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "gitid", - |m: &criu_version| { &m.gitid }, - |m: &mut criu_version| { &mut m.gitid }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "sublevel", - |m: &criu_version| { &m.sublevel }, - |m: &mut criu_version| { &mut m.sublevel }, - )); - fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>( - "extra", - |m: &criu_version| { &m.extra }, - |m: &mut criu_version| { &mut m.extra }, - )); - fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( - "name", - |m: &criu_version| { &m.name }, - |m: &mut criu_version| { &mut m.name }, - )); - ::protobuf::reflect::MessageDescriptor::new_pb_name::( - "criu_version", - fields, - file_descriptor_proto() - ) - }) - } - - fn default_instance() -> &'static criu_version { - static instance: ::protobuf::rt::LazyV2 = ::protobuf::rt::LazyV2::INIT; - instance.get(criu_version::new) - } -} - -impl ::protobuf::Clear for criu_version { - fn clear(&mut self) { - self.major_number = ::std::option::Option::None; - self.minor_number = ::std::option::Option::None; - self.gitid.clear(); - self.sublevel = ::std::option::Option::None; - self.extra = ::std::option::Option::None; - self.name.clear(); - self.unknown_fields.clear(); - } -} - -impl ::std::fmt::Debug for criu_version { - fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result { - ::protobuf::text_format::fmt(self, f) - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_version { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Message(self) - } -} - -#[derive(Clone,PartialEq,Eq,Debug,Hash)] -pub enum criu_cg_mode { - IGNORE = 0, - CG_NONE = 1, - PROPS = 2, - SOFT = 3, - FULL = 4, - STRICT = 5, - DEFAULT = 6, -} - -impl ::protobuf::ProtobufEnum for criu_cg_mode { - fn value(&self) -> i32 { - *self as i32 - } - - fn from_i32(value: i32) -> ::std::option::Option { - match value { - 0 => ::std::option::Option::Some(criu_cg_mode::IGNORE), - 1 => ::std::option::Option::Some(criu_cg_mode::CG_NONE), - 2 => ::std::option::Option::Some(criu_cg_mode::PROPS), - 3 => ::std::option::Option::Some(criu_cg_mode::SOFT), - 4 => ::std::option::Option::Some(criu_cg_mode::FULL), - 5 => ::std::option::Option::Some(criu_cg_mode::STRICT), - 6 => ::std::option::Option::Some(criu_cg_mode::DEFAULT), - _ => ::std::option::Option::None - } - } - - fn values() -> &'static [Self] { - static values: &'static [criu_cg_mode] = &[ - criu_cg_mode::IGNORE, - criu_cg_mode::CG_NONE, - criu_cg_mode::PROPS, - criu_cg_mode::SOFT, - criu_cg_mode::FULL, - criu_cg_mode::STRICT, - criu_cg_mode::DEFAULT, - ]; - values - } - - fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - ::protobuf::reflect::EnumDescriptor::new_pb_name::("criu_cg_mode", file_descriptor_proto()) - }) - } -} - -impl ::std::marker::Copy for criu_cg_mode { -} - -impl ::std::default::Default for criu_cg_mode { - fn default() -> Self { - criu_cg_mode::IGNORE - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_cg_mode { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) - } -} - -#[derive(Clone,PartialEq,Eq,Debug,Hash)] -pub enum criu_pre_dump_mode { - SPLICE = 1, - VM_READ = 2, -} - -impl ::protobuf::ProtobufEnum for criu_pre_dump_mode { - fn value(&self) -> i32 { - *self as i32 - } - - fn from_i32(value: i32) -> ::std::option::Option { - match value { - 1 => ::std::option::Option::Some(criu_pre_dump_mode::SPLICE), - 2 => ::std::option::Option::Some(criu_pre_dump_mode::VM_READ), - _ => ::std::option::Option::None - } - } - - fn values() -> &'static [Self] { - static values: &'static [criu_pre_dump_mode] = &[ - criu_pre_dump_mode::SPLICE, - criu_pre_dump_mode::VM_READ, - ]; - values - } - - fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - ::protobuf::reflect::EnumDescriptor::new_pb_name::("criu_pre_dump_mode", file_descriptor_proto()) - }) - } -} - -impl ::std::marker::Copy for criu_pre_dump_mode { -} - -// Note, `Default` is implemented although default value is not 0 -impl ::std::default::Default for criu_pre_dump_mode { - fn default() -> Self { - criu_pre_dump_mode::SPLICE - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_pre_dump_mode { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) - } -} - -#[derive(Clone,PartialEq,Eq,Debug,Hash)] -pub enum criu_req_type { - EMPTY = 0, - DUMP = 1, - RESTORE = 2, - CHECK = 3, - PRE_DUMP = 4, - PAGE_SERVER = 5, - NOTIFY = 6, - CPUINFO_DUMP = 7, - CPUINFO_CHECK = 8, - FEATURE_CHECK = 9, - VERSION = 10, - WAIT_PID = 11, - PAGE_SERVER_CHLD = 12, -} - -impl ::protobuf::ProtobufEnum for criu_req_type { - fn value(&self) -> i32 { - *self as i32 - } - - fn from_i32(value: i32) -> ::std::option::Option { - match value { - 0 => ::std::option::Option::Some(criu_req_type::EMPTY), - 1 => ::std::option::Option::Some(criu_req_type::DUMP), - 2 => ::std::option::Option::Some(criu_req_type::RESTORE), - 3 => ::std::option::Option::Some(criu_req_type::CHECK), - 4 => ::std::option::Option::Some(criu_req_type::PRE_DUMP), - 5 => ::std::option::Option::Some(criu_req_type::PAGE_SERVER), - 6 => ::std::option::Option::Some(criu_req_type::NOTIFY), - 7 => ::std::option::Option::Some(criu_req_type::CPUINFO_DUMP), - 8 => ::std::option::Option::Some(criu_req_type::CPUINFO_CHECK), - 9 => ::std::option::Option::Some(criu_req_type::FEATURE_CHECK), - 10 => ::std::option::Option::Some(criu_req_type::VERSION), - 11 => ::std::option::Option::Some(criu_req_type::WAIT_PID), - 12 => ::std::option::Option::Some(criu_req_type::PAGE_SERVER_CHLD), - _ => ::std::option::Option::None - } - } - - fn values() -> &'static [Self] { - static values: &'static [criu_req_type] = &[ - criu_req_type::EMPTY, - criu_req_type::DUMP, - criu_req_type::RESTORE, - criu_req_type::CHECK, - criu_req_type::PRE_DUMP, - criu_req_type::PAGE_SERVER, - criu_req_type::NOTIFY, - criu_req_type::CPUINFO_DUMP, - criu_req_type::CPUINFO_CHECK, - criu_req_type::FEATURE_CHECK, - criu_req_type::VERSION, - criu_req_type::WAIT_PID, - criu_req_type::PAGE_SERVER_CHLD, - ]; - values - } - - fn enum_descriptor_static() -> &'static ::protobuf::reflect::EnumDescriptor { - static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::LazyV2::INIT; - descriptor.get(|| { - ::protobuf::reflect::EnumDescriptor::new_pb_name::("criu_req_type", file_descriptor_proto()) - }) - } -} - -impl ::std::marker::Copy for criu_req_type { -} - -impl ::std::default::Default for criu_req_type { - fn default() -> Self { - criu_req_type::EMPTY - } -} - -impl ::protobuf::reflect::ProtobufValue for criu_req_type { - fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { - ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) - } -} - -static file_descriptor_proto_data: &'static [u8] = b"\ - \n\trpc.proto\"q\n\x15criu_page_server_info\x12\x1a\n\x07address\x18\x01\ - \x20\x01(\tR\x07addressB\0\x12\x14\n\x04port\x18\x02\x20\x01(\x05R\x04po\ - rtB\0\x12\x12\n\x03pid\x18\x03\x20\x01(\x05R\x03pidB\0\x12\x10\n\x02fd\ - \x18\x04\x20\x01(\x05R\x02fdB\0:\0\"B\n\x0ecriu_veth_pair\x12\x15\n\x05i\ - f_in\x18\x01\x20\x02(\tR\x04ifInB\0\x12\x17\n\x06if_out\x18\x02\x20\x02(\ - \tR\x05ifOutB\0:\0\"9\n\rext_mount_map\x12\x12\n\x03key\x18\x01\x20\x02(\ - \tR\x03keyB\0\x12\x12\n\x03val\x18\x02\x20\x02(\tR\x03valB\0:\0\"^\n\x0e\ - join_namespace\x12\x10\n\x02ns\x18\x01\x20\x02(\tR\x02nsB\0\x12\x19\n\ - \x07ns_file\x18\x02\x20\x02(\tR\x06nsFileB\0\x12\x1d\n\textra_opt\x18\ - \x03\x20\x01(\tR\x08extraOptB\0:\0\"4\n\ninherit_fd\x12\x12\n\x03key\x18\ - \x01\x20\x02(\tR\x03keyB\0\x12\x10\n\x02fd\x18\x02\x20\x02(\x05R\x02fdB\ - \0:\0\";\n\x0bcgroup_root\x12\x14\n\x04ctrl\x18\x01\x20\x01(\tR\x04ctrlB\ - \0\x12\x14\n\x04path\x18\x02\x20\x02(\tR\x04pathB\0:\0\"#\n\x07unix_sk\ - \x12\x16\n\x05inode\x18\x01\x20\x02(\rR\x05inodeB\0:\0\"\x8a\x12\n\tcriu\ - _opts\x12$\n\rimages_dir_fd\x18\x01\x20\x02(\x05R\x0bimagesDirFdB\0\x12\ - \x12\n\x03pid\x18\x02\x20\x01(\x05R\x03pidB\0\x12%\n\rleave_running\x18\ - \x03\x20\x01(\x08R\x0cleaveRunningB\0\x12\x20\n\x0bext_unix_sk\x18\x04\ - \x20\x01(\x08R\textUnixSkB\0\x12)\n\x0ftcp_established\x18\x05\x20\x01(\ - \x08R\x0etcpEstablishedB\0\x12)\n\x0fevasive_devices\x18\x06\x20\x01(\ - \x08R\x0eevasiveDevicesB\0\x12\x1d\n\tshell_job\x18\x07\x20\x01(\x08R\ - \x08shellJobB\0\x12\x1f\n\nfile_locks\x18\x08\x20\x01(\x08R\tfileLocksB\ - \0\x12\x20\n\tlog_level\x18\t\x20\x01(\x05:\x012R\x08logLevelB\0\x12\x1b\ - \n\x08log_file\x18\n\x20\x01(\tR\x07logFileB\0\x12(\n\x02ps\x18\x0b\x20\ - \x01(\x0b2\x16.criu_page_server_infoR\x02psB\0\x12'\n\x0enotify_scripts\ - \x18\x0c\x20\x01(\x08R\rnotifyScriptsB\0\x12\x14\n\x04root\x18\r\x20\x01\ - (\tR\x04rootB\0\x12\x1f\n\nparent_img\x18\x0e\x20\x01(\tR\tparentImgB\0\ - \x12\x1d\n\ttrack_mem\x18\x0f\x20\x01(\x08R\x08trackMemB\0\x12\x1f\n\nau\ - to_dedup\x18\x10\x20\x01(\x08R\tautoDedupB\0\x12\x20\n\x0bwork_dir_fd\ - \x18\x11\x20\x01(\x05R\tworkDirFdB\0\x12\x1f\n\nlink_remap\x18\x12\x20\ - \x01(\x08R\tlinkRemapB\0\x12'\n\x05veths\x18\x13\x20\x03(\x0b2\x0f.criu_\ - veth_pairR\x05vethsB\0\x12%\n\x07cpu_cap\x18\x14\x20\x01(\r:\n4294967295\ - R\x06cpuCapB\0\x12!\n\x0bforce_irmap\x18\x15\x20\x01(\x08R\nforceIrmapB\ - \0\x12\x1b\n\x08exec_cmd\x18\x16\x20\x03(\tR\x07execCmdB\0\x12)\n\x07ext\ - _mnt\x18\x17\x20\x03(\x0b2\x0e.ext_mount_mapR\x06extMntB\0\x12'\n\x0eman\ - age_cgroups\x18\x18\x20\x01(\x08R\rmanageCgroupsB\0\x12'\n\x07cg_root\ - \x18\x19\x20\x03(\x0b2\x0c.cgroup_rootR\x06cgRootB\0\x12!\n\x0brst_sibli\ - ng\x18\x1a\x20\x01(\x08R\nrstSiblingB\0\x12,\n\ninherit_fd\x18\x1b\x20\ - \x03(\x0b2\x0b.inherit_fdR\tinheritFdB\0\x12\"\n\x0cauto_ext_mnt\x18\x1c\ - \x20\x01(\x08R\nautoExtMntB\0\x12!\n\x0bext_sharing\x18\x1d\x20\x01(\x08\ - R\nextSharingB\0\x12!\n\x0bext_masters\x18\x1e\x20\x01(\x08R\nextMasters\ - B\0\x12\x1b\n\x08skip_mnt\x18\x1f\x20\x03(\tR\x07skipMntB\0\x12\x1d\n\te\ - nable_fs\x18\x20\x20\x03(\tR\x08enableFsB\0\x12*\n\x0bunix_sk_ino\x18!\ - \x20\x03(\x0b2\x08.unix_skR\tunixSkInoB\0\x12?\n\x13manage_cgroups_mode\ - \x18\"\x20\x01(\x0e2\r.criu_cg_modeR\x11manageCgroupsModeB\0\x12*\n\x0bg\ - host_limit\x18#\x20\x01(\r:\x071048576R\nghostLimitB\0\x12*\n\x10irmap_s\ - can_paths\x18$\x20\x03(\tR\x0eirmapScanPathsB\0\x12\x1c\n\x08external\ - \x18%\x20\x03(\tR\x08externalB\0\x12\x1b\n\x08empty_ns\x18&\x20\x01(\rR\ - \x07emptyNsB\0\x12*\n\x07join_ns\x18'\x20\x03(\x0b2\x0f.join_namespaceR\ - \x06joinNsB\0\x12#\n\x0ccgroup_props\x18)\x20\x01(\tR\x0bcgroupPropsB\0\ - \x12,\n\x11cgroup_props_file\x18*\x20\x01(\tR\x0fcgroupPropsFileB\0\x126\ - \n\x16cgroup_dump_controller\x18+\x20\x03(\tR\x14cgroupDumpControllerB\0\ - \x12%\n\rfreeze_cgroup\x18,\x20\x01(\tR\x0cfreezeCgroupB\0\x12\x1a\n\x07\ - timeout\x18-\x20\x01(\rR\x07timeoutB\0\x12-\n\x12tcp_skip_in_flight\x18.\ - \x20\x01(\x08R\x0ftcpSkipInFlightB\0\x12#\n\x0cweak_sysctls\x18/\x20\x01\ - (\x08R\x0bweakSysctlsB\0\x12\x1f\n\nlazy_pages\x180\x20\x01(\x08R\tlazyP\ - agesB\0\x12\x1d\n\tstatus_fd\x181\x20\x01(\x05R\x08statusFdB\0\x12,\n\ - \x11orphan_pts_master\x182\x20\x01(\x08R\x0forphanPtsMasterB\0\x12!\n\ - \x0bconfig_file\x183\x20\x01(\tR\nconfigFileB\0\x12\x1d\n\ttcp_close\x18\ - 4\x20\x01(\x08R\x08tcpCloseB\0\x12!\n\x0blsm_profile\x185\x20\x01(\tR\nl\ - smProfileB\0\x12\x1f\n\ntls_cacert\x186\x20\x01(\tR\ttlsCacertB\0\x12\ - \x1d\n\ttls_cacrl\x187\x20\x01(\tR\x08tlsCacrlB\0\x12\x1b\n\x08tls_cert\ - \x188\x20\x01(\tR\x07tlsCertB\0\x12\x19\n\x07tls_key\x189\x20\x01(\tR\ - \x06tlsKeyB\0\x12\x12\n\x03tls\x18:\x20\x01(\x08R\x03tlsB\0\x12)\n\x10tl\ - s_no_cn_verify\x18;\x20\x01(\x08R\rtlsNoCnVerifyB\0\x12!\n\x0bcgroup_yar\ - d\x18<\x20\x01(\tR\ncgroupYardB\0\x12A\n\rpre_dump_mode\x18=\x20\x01(\ - \x0e2\x13.criu_pre_dump_mode:\x06SPLICER\x0bpreDumpModeB\0\x12&\n\x0epid\ - fd_store_sk\x18>\x20\x01(\x05R\x0cpidfdStoreSkB\0\x12,\n\x11lsm_mount_co\ - ntext\x18?\x20\x01(\tR\x0flsmMountContextB\0:\0\"0\n\x0ecriu_dump_resp\ - \x12\x1c\n\x08restored\x18\x01\x20\x01(\x08R\x08restoredB\0:\0\")\n\x11c\ - riu_restore_resp\x12\x12\n\x03pid\x18\x01\x20\x02(\x05R\x03pidB\0:\0\"=\ - \n\x0bcriu_notify\x12\x18\n\x06script\x18\x01\x20\x01(\tR\x06scriptB\0\ - \x12\x12\n\x03pid\x18\x02\x20\x01(\x05R\x03pidB\0:\0\"t\n\rcriu_features\ - \x12\x1d\n\tmem_track\x18\x01\x20\x01(\x08R\x08memTrackB\0\x12\x1f\n\nla\ - zy_pages\x18\x02\x20\x01(\x08R\tlazyPagesB\0\x12!\n\x0bpidfd_store\x18\ - \x03\x20\x01(\x08R\npidfdStoreB\0:\0\"\xde\x01\n\x08criu_req\x12$\n\x04t\ - ype\x18\x01\x20\x02(\x0e2\x0e.criu_req_typeR\x04typeB\0\x12\x20\n\x04opt\ - s\x18\x02\x20\x01(\x0b2\n.criu_optsR\x04optsB\0\x12'\n\x0enotify_success\ - \x18\x03\x20\x01(\x08R\rnotifySuccessB\0\x12\x1d\n\tkeep_open\x18\x04\ - \x20\x01(\x08R\x08keepOpenB\0\x12,\n\x08features\x18\x05\x20\x01(\x0b2\ - \x0e.criu_featuresR\x08featuresB\0\x12\x12\n\x03pid\x18\x06\x20\x01(\rR\ - \x03pidB\0:\0\"\xa7\x03\n\tcriu_resp\x12$\n\x04type\x18\x01\x20\x02(\x0e\ - 2\x0e.criu_req_typeR\x04typeB\0\x12\x1a\n\x07success\x18\x02\x20\x02(\ - \x08R\x07successB\0\x12%\n\x04dump\x18\x03\x20\x01(\x0b2\x0f.criu_dump_r\ - espR\x04dumpB\0\x12.\n\x07restore\x18\x04\x20\x01(\x0b2\x12.criu_restore\ - _respR\x07restoreB\0\x12&\n\x06notify\x18\x05\x20\x01(\x0b2\x0c.criu_not\ - ifyR\x06notifyB\0\x12(\n\x02ps\x18\x06\x20\x01(\x0b2\x16.criu_page_serve\ - r_infoR\x02psB\0\x12\x1b\n\x08cr_errno\x18\x07\x20\x01(\x05R\x07crErrnoB\ - \0\x12,\n\x08features\x18\x08\x20\x01(\x0b2\x0e.criu_featuresR\x08featur\ - esB\0\x12\x1d\n\tcr_errmsg\x18\t\x20\x01(\tR\x08crErrmsgB\0\x12)\n\x07ve\ - rsion\x18\n\x20\x01(\x0b2\r.criu_versionR\x07versionB\0\x12\x18\n\x06sta\ - tus\x18\x0b\x20\x01(\x05R\x06statusB\0:\0\"\xbe\x01\n\x0ccriu_version\ - \x12#\n\x0cmajor_number\x18\x01\x20\x02(\x05R\x0bmajorNumberB\0\x12#\n\ - \x0cminor_number\x18\x02\x20\x02(\x05R\x0bminorNumberB\0\x12\x16\n\x05gi\ - tid\x18\x03\x20\x01(\tR\x05gitidB\0\x12\x1c\n\x08sublevel\x18\x04\x20\ - \x01(\x05R\x08sublevelB\0\x12\x16\n\x05extra\x18\x05\x20\x01(\x05R\x05ex\ - traB\0\x12\x14\n\x04name\x18\x06\x20\x01(\tR\x04nameB\0:\0*a\n\x0ccriu_c\ - g_mode\x12\n\n\x06IGNORE\x10\0\x12\x0b\n\x07CG_NONE\x10\x01\x12\t\n\x05P\ - ROPS\x10\x02\x12\x08\n\x04SOFT\x10\x03\x12\x08\n\x04FULL\x10\x04\x12\n\n\ - \x06STRICT\x10\x05\x12\x0b\n\x07DEFAULT\x10\x06\x1a\0*/\n\x12criu_pre_du\ - mp_mode\x12\n\n\x06SPLICE\x10\x01\x12\x0b\n\x07VM_READ\x10\x02\x1a\0*\ - \xd2\x01\n\rcriu_req_type\x12\t\n\x05EMPTY\x10\0\x12\x08\n\x04DUMP\x10\ - \x01\x12\x0b\n\x07RESTORE\x10\x02\x12\t\n\x05CHECK\x10\x03\x12\x0c\n\x08\ - PRE_DUMP\x10\x04\x12\x0f\n\x0bPAGE_SERVER\x10\x05\x12\n\n\x06NOTIFY\x10\ - \x06\x12\x10\n\x0cCPUINFO_DUMP\x10\x07\x12\x11\n\rCPUINFO_CHECK\x10\x08\ - \x12\x11\n\rFEATURE_CHECK\x10\t\x12\x0b\n\x07VERSION\x10\n\x12\x0c\n\x08\ - WAIT_PID\x10\x0b\x12\x14\n\x10PAGE_SERVER_CHLD\x10\x0c\x1a\0B\0b\x06prot\ - o2\ -"; - -static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT; - -fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { - ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap() -} - -pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { - file_descriptor_proto_lazy.get(|| { - parse_descriptor_proto() - }) -}