#![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)]
const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_2_0;
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_page_server_info {
pub address: ::std::option::Option<::std::string::String>,
pub port: ::std::option::Option<i32>,
pub pid: ::std::option::Option<i32>,
pub fd: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_page_server_info {
fn default() -> &'a Criu_page_server_info {
<Criu_page_server_info as ::protobuf::Message>::default_instance()
}
}
impl Criu_page_server_info {
pub fn new() -> Criu_page_server_info {
::std::default::Default::default()
}
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()
}
pub fn set_address(&mut self, v: ::std::string::String) {
self.address = ::std::option::Option::Some(v);
}
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()
}
pub fn take_address(&mut self) -> ::std::string::String {
self.address.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_port(&mut self, v: i32) {
self.port = ::std::option::Option::Some(v);
}
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()
}
pub fn set_pid(&mut self, v: i32) {
self.pid = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_veth_pair {
pub if_in: ::std::option::Option<::std::string::String>,
pub if_out: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_veth_pair {
fn default() -> &'a Criu_veth_pair {
<Criu_veth_pair as ::protobuf::Message>::default_instance()
}
}
impl Criu_veth_pair {
pub fn new() -> Criu_veth_pair {
::std::default::Default::default()
}
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()
}
pub fn set_if_in(&mut self, v: ::std::string::String) {
self.if_in = ::std::option::Option::Some(v);
}
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()
}
pub fn take_if_in(&mut self) -> ::std::string::String {
self.if_in.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_if_out(&mut self, v: ::std::string::String) {
self.if_out = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Ext_mount_map {
pub key: ::std::option::Option<::std::string::String>,
pub val: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Ext_mount_map {
fn default() -> &'a Ext_mount_map {
<Ext_mount_map as ::protobuf::Message>::default_instance()
}
}
impl Ext_mount_map {
pub fn new() -> Ext_mount_map {
::std::default::Default::default()
}
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()
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = ::std::option::Option::Some(v);
}
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()
}
pub fn take_key(&mut self) -> ::std::string::String {
self.key.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_val(&mut self, v: ::std::string::String) {
self.val = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Join_namespace {
pub ns: ::std::option::Option<::std::string::String>,
pub ns_file: ::std::option::Option<::std::string::String>,
pub extra_opt: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Join_namespace {
fn default() -> &'a Join_namespace {
<Join_namespace as ::protobuf::Message>::default_instance()
}
}
impl Join_namespace {
pub fn new() -> Join_namespace {
::std::default::Default::default()
}
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()
}
pub fn set_ns(&mut self, v: ::std::string::String) {
self.ns = ::std::option::Option::Some(v);
}
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()
}
pub fn take_ns(&mut self) -> ::std::string::String {
self.ns.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_ns_file(&mut self, v: ::std::string::String) {
self.ns_file = ::std::option::Option::Some(v);
}
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()
}
pub fn take_ns_file(&mut self) -> ::std::string::String {
self.ns_file.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_extra_opt(&mut self, v: ::std::string::String) {
self.extra_opt = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Inherit_fd {
pub key: ::std::option::Option<::std::string::String>,
pub fd: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Inherit_fd {
fn default() -> &'a Inherit_fd {
<Inherit_fd as ::protobuf::Message>::default_instance()
}
}
impl Inherit_fd {
pub fn new() -> Inherit_fd {
::std::default::Default::default()
}
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()
}
pub fn set_key(&mut self, v: ::std::string::String) {
self.key = ::std::option::Option::Some(v);
}
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()
}
pub fn take_key(&mut self) -> ::std::string::String {
self.key.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Cgroup_root {
pub ctrl: ::std::option::Option<::std::string::String>,
pub path: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Cgroup_root {
fn default() -> &'a Cgroup_root {
<Cgroup_root as ::protobuf::Message>::default_instance()
}
}
impl Cgroup_root {
pub fn new() -> Cgroup_root {
::std::default::Default::default()
}
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()
}
pub fn set_ctrl(&mut self, v: ::std::string::String) {
self.ctrl = ::std::option::Option::Some(v);
}
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()
}
pub fn take_ctrl(&mut self) -> ::std::string::String {
self.ctrl.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_path(&mut self, v: ::std::string::String) {
self.path = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Unix_sk {
pub inode: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Unix_sk {
fn default() -> &'a Unix_sk {
<Unix_sk as ::protobuf::Message>::default_instance()
}
}
impl Unix_sk {
pub fn new() -> Unix_sk {
::std::default::Default::default()
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_opts {
pub images_dir_fd: ::std::option::Option<i32>,
pub pid: ::std::option::Option<i32>,
pub leave_running: ::std::option::Option<bool>,
pub ext_unix_sk: ::std::option::Option<bool>,
pub tcp_established: ::std::option::Option<bool>,
pub evasive_devices: ::std::option::Option<bool>,
pub shell_job: ::std::option::Option<bool>,
pub file_locks: ::std::option::Option<bool>,
pub log_level: ::std::option::Option<i32>,
pub log_file: ::std::option::Option<::std::string::String>,
pub ps: ::protobuf::MessageField<Criu_page_server_info>,
pub notify_scripts: ::std::option::Option<bool>,
pub root: ::std::option::Option<::std::string::String>,
pub parent_img: ::std::option::Option<::std::string::String>,
pub track_mem: ::std::option::Option<bool>,
pub auto_dedup: ::std::option::Option<bool>,
pub work_dir_fd: ::std::option::Option<i32>,
pub link_remap: ::std::option::Option<bool>,
pub veths: ::std::vec::Vec<Criu_veth_pair>,
pub cpu_cap: ::std::option::Option<u32>,
pub force_irmap: ::std::option::Option<bool>,
pub exec_cmd: ::std::vec::Vec<::std::string::String>,
pub ext_mnt: ::std::vec::Vec<Ext_mount_map>,
pub manage_cgroups: ::std::option::Option<bool>,
pub cg_root: ::std::vec::Vec<Cgroup_root>,
pub rst_sibling: ::std::option::Option<bool>,
pub inherit_fd: ::std::vec::Vec<Inherit_fd>,
pub auto_ext_mnt: ::std::option::Option<bool>,
pub ext_sharing: ::std::option::Option<bool>,
pub ext_masters: ::std::option::Option<bool>,
pub skip_mnt: ::std::vec::Vec<::std::string::String>,
pub enable_fs: ::std::vec::Vec<::std::string::String>,
pub unix_sk_ino: ::std::vec::Vec<Unix_sk>,
pub manage_cgroups_mode: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_cg_mode>>,
pub ghost_limit: ::std::option::Option<u32>,
pub irmap_scan_paths: ::std::vec::Vec<::std::string::String>,
pub external: ::std::vec::Vec<::std::string::String>,
pub empty_ns: ::std::option::Option<u32>,
pub join_ns: ::std::vec::Vec<Join_namespace>,
pub cgroup_props: ::std::option::Option<::std::string::String>,
pub cgroup_props_file: ::std::option::Option<::std::string::String>,
pub cgroup_dump_controller: ::std::vec::Vec<::std::string::String>,
pub freeze_cgroup: ::std::option::Option<::std::string::String>,
pub timeout: ::std::option::Option<u32>,
pub tcp_skip_in_flight: ::std::option::Option<bool>,
pub weak_sysctls: ::std::option::Option<bool>,
pub lazy_pages: ::std::option::Option<bool>,
pub status_fd: ::std::option::Option<i32>,
pub orphan_pts_master: ::std::option::Option<bool>,
pub config_file: ::std::option::Option<::std::string::String>,
pub tcp_close: ::std::option::Option<bool>,
pub lsm_profile: ::std::option::Option<::std::string::String>,
pub tls_cacert: ::std::option::Option<::std::string::String>,
pub tls_cacrl: ::std::option::Option<::std::string::String>,
pub tls_cert: ::std::option::Option<::std::string::String>,
pub tls_key: ::std::option::Option<::std::string::String>,
pub tls: ::std::option::Option<bool>,
pub tls_no_cn_verify: ::std::option::Option<bool>,
pub cgroup_yard: ::std::option::Option<::std::string::String>,
pub pre_dump_mode: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_pre_dump_mode>>,
pub pidfd_store_sk: ::std::option::Option<i32>,
pub lsm_mount_context: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_opts {
fn default() -> &'a Criu_opts {
<Criu_opts as ::protobuf::Message>::default_instance()
}
}
impl Criu_opts {
pub fn new() -> Criu_opts {
::std::default::Default::default()
}
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()
}
pub fn set_images_dir_fd(&mut self, v: i32) {
self.images_dir_fd = ::std::option::Option::Some(v);
}
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()
}
pub fn set_pid(&mut self, v: i32) {
self.pid = ::std::option::Option::Some(v);
}
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()
}
pub fn set_leave_running(&mut self, v: bool) {
self.leave_running = ::std::option::Option::Some(v);
}
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()
}
pub fn set_ext_unix_sk(&mut self, v: bool) {
self.ext_unix_sk = ::std::option::Option::Some(v);
}
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()
}
pub fn set_tcp_established(&mut self, v: bool) {
self.tcp_established = ::std::option::Option::Some(v);
}
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()
}
pub fn set_evasive_devices(&mut self, v: bool) {
self.evasive_devices = ::std::option::Option::Some(v);
}
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()
}
pub fn set_shell_job(&mut self, v: bool) {
self.shell_job = ::std::option::Option::Some(v);
}
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()
}
pub fn set_file_locks(&mut self, v: bool) {
self.file_locks = ::std::option::Option::Some(v);
}
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()
}
pub fn set_log_level(&mut self, v: i32) {
self.log_level = ::std::option::Option::Some(v);
}
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()
}
pub fn set_log_file(&mut self, v: ::std::string::String) {
self.log_file = ::std::option::Option::Some(v);
}
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()
}
pub fn take_log_file(&mut self) -> ::std::string::String {
self.log_file.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_notify_scripts(&mut self, v: bool) {
self.notify_scripts = ::std::option::Option::Some(v);
}
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()
}
pub fn set_root(&mut self, v: ::std::string::String) {
self.root = ::std::option::Option::Some(v);
}
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()
}
pub fn take_root(&mut self) -> ::std::string::String {
self.root.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_parent_img(&mut self, v: ::std::string::String) {
self.parent_img = ::std::option::Option::Some(v);
}
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()
}
pub fn take_parent_img(&mut self) -> ::std::string::String {
self.parent_img.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_track_mem(&mut self, v: bool) {
self.track_mem = ::std::option::Option::Some(v);
}
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()
}
pub fn set_auto_dedup(&mut self, v: bool) {
self.auto_dedup = ::std::option::Option::Some(v);
}
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()
}
pub fn set_work_dir_fd(&mut self, v: i32) {
self.work_dir_fd = ::std::option::Option::Some(v);
}
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()
}
pub fn set_link_remap(&mut self, v: bool) {
self.link_remap = ::std::option::Option::Some(v);
}
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()
}
pub fn set_cpu_cap(&mut self, v: u32) {
self.cpu_cap = ::std::option::Option::Some(v);
}
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()
}
pub fn set_force_irmap(&mut self, v: bool) {
self.force_irmap = ::std::option::Option::Some(v);
}
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()
}
pub fn set_manage_cgroups(&mut self, v: bool) {
self.manage_cgroups = ::std::option::Option::Some(v);
}
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()
}
pub fn set_rst_sibling(&mut self, v: bool) {
self.rst_sibling = ::std::option::Option::Some(v);
}
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()
}
pub fn set_auto_ext_mnt(&mut self, v: bool) {
self.auto_ext_mnt = ::std::option::Option::Some(v);
}
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()
}
pub fn set_ext_sharing(&mut self, v: bool) {
self.ext_sharing = ::std::option::Option::Some(v);
}
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()
}
pub fn set_ext_masters(&mut self, v: bool) {
self.ext_masters = ::std::option::Option::Some(v);
}
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()
}
pub fn set_manage_cgroups_mode(&mut self, v: Criu_cg_mode) {
self.manage_cgroups_mode = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
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()
}
pub fn set_ghost_limit(&mut self, v: u32) {
self.ghost_limit = ::std::option::Option::Some(v);
}
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()
}
pub fn set_empty_ns(&mut self, v: u32) {
self.empty_ns = ::std::option::Option::Some(v);
}
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()
}
pub fn set_cgroup_props(&mut self, v: ::std::string::String) {
self.cgroup_props = ::std::option::Option::Some(v);
}
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()
}
pub fn take_cgroup_props(&mut self) -> ::std::string::String {
self.cgroup_props.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_cgroup_props_file(&mut self, v: ::std::string::String) {
self.cgroup_props_file = ::std::option::Option::Some(v);
}
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()
}
pub fn take_cgroup_props_file(&mut self) -> ::std::string::String {
self.cgroup_props_file.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_freeze_cgroup(&mut self, v: ::std::string::String) {
self.freeze_cgroup = ::std::option::Option::Some(v);
}
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()
}
pub fn take_freeze_cgroup(&mut self) -> ::std::string::String {
self.freeze_cgroup.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_timeout(&mut self, v: u32) {
self.timeout = ::std::option::Option::Some(v);
}
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()
}
pub fn set_tcp_skip_in_flight(&mut self, v: bool) {
self.tcp_skip_in_flight = ::std::option::Option::Some(v);
}
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()
}
pub fn set_weak_sysctls(&mut self, v: bool) {
self.weak_sysctls = ::std::option::Option::Some(v);
}
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()
}
pub fn set_lazy_pages(&mut self, v: bool) {
self.lazy_pages = ::std::option::Option::Some(v);
}
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()
}
pub fn set_status_fd(&mut self, v: i32) {
self.status_fd = ::std::option::Option::Some(v);
}
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()
}
pub fn set_orphan_pts_master(&mut self, v: bool) {
self.orphan_pts_master = ::std::option::Option::Some(v);
}
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()
}
pub fn set_config_file(&mut self, v: ::std::string::String) {
self.config_file = ::std::option::Option::Some(v);
}
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()
}
pub fn take_config_file(&mut self) -> ::std::string::String {
self.config_file.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tcp_close(&mut self, v: bool) {
self.tcp_close = ::std::option::Option::Some(v);
}
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()
}
pub fn set_lsm_profile(&mut self, v: ::std::string::String) {
self.lsm_profile = ::std::option::Option::Some(v);
}
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()
}
pub fn take_lsm_profile(&mut self) -> ::std::string::String {
self.lsm_profile.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tls_cacert(&mut self, v: ::std::string::String) {
self.tls_cacert = ::std::option::Option::Some(v);
}
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()
}
pub fn take_tls_cacert(&mut self) -> ::std::string::String {
self.tls_cacert.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tls_cacrl(&mut self, v: ::std::string::String) {
self.tls_cacrl = ::std::option::Option::Some(v);
}
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()
}
pub fn take_tls_cacrl(&mut self) -> ::std::string::String {
self.tls_cacrl.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tls_cert(&mut self, v: ::std::string::String) {
self.tls_cert = ::std::option::Option::Some(v);
}
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()
}
pub fn take_tls_cert(&mut self) -> ::std::string::String {
self.tls_cert.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tls_key(&mut self, v: ::std::string::String) {
self.tls_key = ::std::option::Option::Some(v);
}
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()
}
pub fn take_tls_key(&mut self) -> ::std::string::String {
self.tls_key.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_tls(&mut self, v: bool) {
self.tls = ::std::option::Option::Some(v);
}
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()
}
pub fn set_tls_no_cn_verify(&mut self, v: bool) {
self.tls_no_cn_verify = ::std::option::Option::Some(v);
}
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()
}
pub fn set_cgroup_yard(&mut self, v: ::std::string::String) {
self.cgroup_yard = ::std::option::Option::Some(v);
}
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()
}
pub fn take_cgroup_yard(&mut self) -> ::std::string::String {
self.cgroup_yard.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
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));
}
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()
}
pub fn set_pidfd_store_sk(&mut self, v: i32) {
self.pidfd_store_sk = ::std::option::Option::Some(v);
}
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()
}
pub fn set_lsm_mount_context(&mut self, v: ::std::string::String) {
self.lsm_mount_context = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_dump_resp {
pub restored: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_dump_resp {
fn default() -> &'a Criu_dump_resp {
<Criu_dump_resp as ::protobuf::Message>::default_instance()
}
}
impl Criu_dump_resp {
pub fn new() -> Criu_dump_resp {
::std::default::Default::default()
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_restore_resp {
pub pid: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_restore_resp {
fn default() -> &'a Criu_restore_resp {
<Criu_restore_resp as ::protobuf::Message>::default_instance()
}
}
impl Criu_restore_resp {
pub fn new() -> Criu_restore_resp {
::std::default::Default::default()
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_notify {
pub script: ::std::option::Option<::std::string::String>,
pub pid: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_notify {
fn default() -> &'a Criu_notify {
<Criu_notify as ::protobuf::Message>::default_instance()
}
}
impl Criu_notify {
pub fn new() -> Criu_notify {
::std::default::Default::default()
}
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()
}
pub fn set_script(&mut self, v: ::std::string::String) {
self.script = ::std::option::Option::Some(v);
}
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()
}
pub fn take_script(&mut self) -> ::std::string::String {
self.script.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_features {
pub mem_track: ::std::option::Option<bool>,
pub lazy_pages: ::std::option::Option<bool>,
pub pidfd_store: ::std::option::Option<bool>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_features {
fn default() -> &'a Criu_features {
<Criu_features as ::protobuf::Message>::default_instance()
}
}
impl Criu_features {
pub fn new() -> Criu_features {
::std::default::Default::default()
}
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()
}
pub fn set_mem_track(&mut self, v: bool) {
self.mem_track = ::std::option::Option::Some(v);
}
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()
}
pub fn set_lazy_pages(&mut self, v: bool) {
self.lazy_pages = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_req {
pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_req_type>>,
pub opts: ::protobuf::MessageField<Criu_opts>,
pub notify_success: ::std::option::Option<bool>,
pub keep_open: ::std::option::Option<bool>,
pub features: ::protobuf::MessageField<Criu_features>,
pub pid: ::std::option::Option<u32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_req {
fn default() -> &'a Criu_req {
<Criu_req as ::protobuf::Message>::default_instance()
}
}
impl Criu_req {
pub fn new() -> Criu_req {
::std::default::Default::default()
}
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()
}
pub fn set_type(&mut self, v: Criu_req_type) {
self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
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()
}
pub fn set_notify_success(&mut self, v: bool) {
self.notify_success = ::std::option::Option::Some(v);
}
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()
}
pub fn set_keep_open(&mut self, v: bool) {
self.keep_open = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_resp {
pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<Criu_req_type>>,
pub success: ::std::option::Option<bool>,
pub dump: ::protobuf::MessageField<Criu_dump_resp>,
pub restore: ::protobuf::MessageField<Criu_restore_resp>,
pub notify: ::protobuf::MessageField<Criu_notify>,
pub ps: ::protobuf::MessageField<Criu_page_server_info>,
pub cr_errno: ::std::option::Option<i32>,
pub features: ::protobuf::MessageField<Criu_features>,
pub cr_errmsg: ::std::option::Option<::std::string::String>,
pub version: ::protobuf::MessageField<Criu_version>,
pub status: ::std::option::Option<i32>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_resp {
fn default() -> &'a Criu_resp {
<Criu_resp as ::protobuf::Message>::default_instance()
}
}
impl Criu_resp {
pub fn new() -> Criu_resp {
::std::default::Default::default()
}
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()
}
pub fn set_type(&mut self, v: Criu_req_type) {
self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
}
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()
}
pub fn set_success(&mut self, v: bool) {
self.success = ::std::option::Option::Some(v);
}
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()
}
pub fn set_cr_errno(&mut self, v: i32) {
self.cr_errno = ::std::option::Option::Some(v);
}
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()
}
pub fn set_cr_errmsg(&mut self, v: ::std::string::String) {
self.cr_errmsg = ::std::option::Option::Some(v);
}
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()
}
pub fn take_cr_errmsg(&mut self) -> ::std::string::String {
self.cr_errmsg.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(PartialEq,Clone,Default,Debug)]
pub struct Criu_version {
pub major_number: ::std::option::Option<i32>,
pub minor_number: ::std::option::Option<i32>,
pub gitid: ::std::option::Option<::std::string::String>,
pub sublevel: ::std::option::Option<i32>,
pub extra: ::std::option::Option<i32>,
pub name: ::std::option::Option<::std::string::String>,
pub special_fields: ::protobuf::SpecialFields,
}
impl<'a> ::std::default::Default for &'a Criu_version {
fn default() -> &'a Criu_version {
<Criu_version as ::protobuf::Message>::default_instance()
}
}
impl Criu_version {
pub fn new() -> Criu_version {
::std::default::Default::default()
}
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()
}
pub fn set_major_number(&mut self, v: i32) {
self.major_number = ::std::option::Option::Some(v);
}
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()
}
pub fn set_minor_number(&mut self, v: i32) {
self.minor_number = ::std::option::Option::Some(v);
}
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()
}
pub fn set_gitid(&mut self, v: ::std::string::String) {
self.gitid = ::std::option::Option::Some(v);
}
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()
}
pub fn take_gitid(&mut self) -> ::std::string::String {
self.gitid.take().unwrap_or_else(|| ::std::string::String::new())
}
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()
}
pub fn set_sublevel(&mut self, v: i32) {
self.sublevel = ::std::option::Option::Some(v);
}
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()
}
pub fn set_extra(&mut self, v: i32) {
self.extra = ::std::option::Option::Some(v);
}
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()
}
pub fn set_name(&mut self, v: ::std::string::String) {
self.name = ::std::option::Option::Some(v);
}
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()
}
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>(
"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(())
}
#[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<Self>;
}
#[derive(Clone,Copy,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::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<Criu_cg_mode> {
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>("criu_cg_mode")
}
}
#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
pub enum Criu_pre_dump_mode {
SPLICE = 1,
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<Criu_pre_dump_mode> {
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)
}
}
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>("criu_pre_dump_mode")
}
}
#[derive(Clone,Copy,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::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<Criu_req_type> {
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>("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\
";
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()
})
}
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)
})
}