Add files using upload-large-folder tool

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/custom_default_format.rs

@@ -0,0 +1,39 @@
+/*!
+Disabling parts of the default format.
+
+Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
+
+```no_run,shell
+$ export MY_LOG_LEVEL='info'
+```
+
+Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
+or `auto` to enable them:
+
+```no_run,shell
+$ export MY_LOG_STYLE=never
+```
+
+If you want to control the logging output completely, see the `custom_logger` example.
+*/
+
+use log::info;
+
+use env_logger::{Builder, Env};
+
+fn init_logger() {
+    let env = Env::default()
+        .filter("MY_LOG_LEVEL")
+        .write_style("MY_LOG_STYLE");
+
+    Builder::from_env(env)
+        .format_level(false)
+        .format_timestamp_nanos()
+        .init();
+}
+
+fn main() {
+    init_logger();
+
+    info!("a log from `MyLogger`");
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/custom_format.rs

@@ -0,0 +1,53 @@
+/*!
+Changing the default logging format.
+
+Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
+
+```no_run,shell
+$ export MY_LOG_LEVEL='info'
+```
+
+Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
+or `auto` to enable them:
+
+```no_run,shell
+$ export MY_LOG_STYLE=never
+```
+
+If you want to control the logging output completely, see the `custom_logger` example.
+*/
+
+#[cfg(all(feature = "color", feature = "humantime"))]
+fn main() {
+    use env_logger::{Builder, Env};
+
+    use std::io::Write;
+
+    fn init_logger() {
+        let env = Env::default()
+            .filter("MY_LOG_LEVEL")
+            .write_style("MY_LOG_STYLE");
+
+        Builder::from_env(env)
+            .format(|buf, record| {
+                // We are reusing `anstyle` but there are `anstyle-*` crates to adapt it to your
+                // preferred styling crate.
+                let warn_style = buf.default_level_style(log::Level::Warn);
+                let timestamp = buf.timestamp();
+
+                writeln!(
+                    buf,
+                    "My formatted log ({timestamp}): {warn_style}{}{warn_style:#}",
+                    record.args()
+                )
+            })
+            .init();
+    }
+
+    init_logger();
+
+    log::info!("a log from `MyLogger`");
+}
+
+#[cfg(not(all(feature = "color", feature = "humantime")))]
+fn main() {}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/default.rs

@@ -0,0 +1,37 @@
+/*!
+Using `env_logger`.
+
+Before running this example, try setting the `MY_LOG_LEVEL` environment variable to `info`:
+
+```no_run,shell
+$ export MY_LOG_LEVEL='info'
+```
+
+Also try setting the `MY_LOG_STYLE` environment variable to `never` to disable colors
+or `auto` to enable them:
+
+```no_run,shell
+$ export MY_LOG_STYLE=never
+```
+*/
+
+use log::{debug, error, info, trace, warn};
+
+use env_logger::Env;
+
+fn main() {
+    // The `Env` lets us tweak what the environment
+    // variables to read are and what the default
+    // value is if they're missing
+    let env = Env::default()
+        .filter_or("MY_LOG_LEVEL", "trace")
+        .write_style_or("MY_LOG_STYLE", "always");
+
+    env_logger::init_from_env(env);
+
+    trace!("some trace log");
+    debug!("some debug log");
+    info!("some information log");
+    warn!("some warning log");
+    error!("some error log");
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/direct_logger.rs

@@ -0,0 +1,47 @@
+/*!
+Using `env_logger::Logger` and the `log::Log` trait directly.
+
+This example doesn't rely on environment variables, or having a static logger installed.
+*/
+
+use env_logger::{Builder, WriteStyle};
+
+use log::{Level, LevelFilter, Log, MetadataBuilder, Record};
+
+#[cfg(feature = "kv")]
+static KVS: (&str, &str) = ("test", "something");
+
+fn record() -> Record<'static> {
+    let error_metadata = MetadataBuilder::new()
+        .target("myApp")
+        .level(Level::Error)
+        .build();
+
+    let mut builder = Record::builder();
+    builder
+        .metadata(error_metadata)
+        .args(format_args!("Error!"))
+        .line(Some(433))
+        .file(Some("app.rs"))
+        .module_path(Some("server"));
+    #[cfg(feature = "kv")]
+    {
+        builder.key_values(&KVS);
+    }
+    builder.build()
+}
+
+fn main() {
+    let stylish_logger = Builder::new()
+        .filter(None, LevelFilter::Error)
+        .write_style(WriteStyle::Always)
+        .build();
+
+    let unstylish_logger = Builder::new()
+        .filter(None, LevelFilter::Error)
+        .write_style(WriteStyle::Never)
+        .build();
+
+    stylish_logger.log(&record());
+    unstylish_logger.log(&record());
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/filters_from_code.rs

@@ -0,0 +1,17 @@
+/*!
+Specify logging filters in code instead of using an environment variable.
+*/
+
+use env_logger::Builder;
+
+use log::{debug, error, info, trace, warn, LevelFilter};
+
+fn main() {
+    Builder::new().filter_level(LevelFilter::max()).init();
+
+    trace!("some trace log");
+    debug!("some debug log");
+    info!("some information log");
+    warn!("some warning log");
+    error!("some error log");
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/in_tests.rs

@@ -0,0 +1,53 @@
+/*!
+Using `env_logger` in tests.
+
+Log events will be captured by `cargo` and only printed if the test fails.
+You can run this example by calling:
+
+```text
+cargo test --example in_tests
+```
+
+You should see the `it_does_not_work` test fail and include its log output.
+*/
+
+fn main() {}
+
+#[cfg(test)]
+mod tests {
+    use log::debug;
+
+    fn init_logger() {
+        let _ = env_logger::builder()
+            // Include all events in tests
+            .filter_level(log::LevelFilter::max())
+            // Ensure events are captured by `cargo test`
+            .is_test(true)
+            // Ignore errors initializing the logger if tests race to configure it
+            .try_init();
+    }
+
+    #[test]
+    fn it_works() {
+        init_logger();
+
+        let a = 1;
+        let b = 2;
+
+        debug!("checking whether {} + {} = 3", a, b);
+
+        assert_eq!(3, a + b);
+    }
+
+    #[test]
+    fn it_does_not_work() {
+        init_logger();
+
+        let a = 1;
+        let b = 2;
+
+        debug!("checking whether {} + {} = 6", a, b);
+
+        assert_eq!(6, a + b);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/examples/syslog_friendly_format.rs

@@ -0,0 +1,24 @@
+use std::io::Write;
+
+fn main() {
+    match std::env::var("RUST_LOG_STYLE") {
+        Ok(s) if s == "SYSTEMD" => env_logger::builder()
+            .format(|buf, record| {
+                writeln!(
+                    buf,
+                    "<{}>{}: {}",
+                    match record.level() {
+                        log::Level::Error => 3,
+                        log::Level::Warn => 4,
+                        log::Level::Info => 6,
+                        log::Level::Debug => 7,
+                        log::Level::Trace => 7,
+                    },
+                    record.target(),
+                    record.args()
+                )
+            })
+            .init(),
+        _ => env_logger::init(),
+    };
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/fmt/humantime.rs

@@ -0,0 +1,134 @@
+use std::fmt;
+use std::time::SystemTime;
+
+use crate::fmt::{Formatter, TimestampPrecision};
+
+impl Formatter {
+    /// Get a [`Timestamp`] for the current date and time in UTC.
+    ///
+    /// # Examples
+    ///
+    /// Include the current timestamp with the log record:
+    ///
+    /// ```
+    /// use std::io::Write;
+    ///
+    /// let mut builder = env_logger::Builder::new();
+    ///
+    /// builder.format(|buf, record| {
+    ///     let ts = buf.timestamp();
+    ///
+    ///     writeln!(buf, "{}: {}: {}", ts, record.level(), record.args())
+    /// });
+    /// ```
+    pub fn timestamp(&self) -> Timestamp {
+        Timestamp {
+            time: SystemTime::now(),
+            precision: TimestampPrecision::Seconds,
+        }
+    }
+
+    /// Get a [`Timestamp`] for the current date and time in UTC with full
+    /// second precision.
+    pub fn timestamp_seconds(&self) -> Timestamp {
+        Timestamp {
+            time: SystemTime::now(),
+            precision: TimestampPrecision::Seconds,
+        }
+    }
+
+    /// Get a [`Timestamp`] for the current date and time in UTC with
+    /// millisecond precision.
+    pub fn timestamp_millis(&self) -> Timestamp {
+        Timestamp {
+            time: SystemTime::now(),
+            precision: TimestampPrecision::Millis,
+        }
+    }
+
+    /// Get a [`Timestamp`] for the current date and time in UTC with
+    /// microsecond precision.
+    pub fn timestamp_micros(&self) -> Timestamp {
+        Timestamp {
+            time: SystemTime::now(),
+            precision: TimestampPrecision::Micros,
+        }
+    }
+
+    /// Get a [`Timestamp`] for the current date and time in UTC with
+    /// nanosecond precision.
+    pub fn timestamp_nanos(&self) -> Timestamp {
+        Timestamp {
+            time: SystemTime::now(),
+            precision: TimestampPrecision::Nanos,
+        }
+    }
+}
+
+/// An [RFC3339] formatted timestamp.
+///
+/// The timestamp implements [`Display`] and can be written to a [`Formatter`].
+///
+/// [RFC3339]: https://www.ietf.org/rfc/rfc3339.txt
+/// [`Display`]: std::fmt::Display
+pub struct Timestamp {
+    time: SystemTime,
+    precision: TimestampPrecision,
+}
+
+impl fmt::Debug for Timestamp {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        /// A `Debug` wrapper for `Timestamp` that uses the `Display` implementation.
+        struct TimestampValue<'a>(&'a Timestamp);
+
+        impl fmt::Debug for TimestampValue<'_> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                fmt::Display::fmt(&self.0, f)
+            }
+        }
+
+        f.debug_tuple("Timestamp")
+            .field(&TimestampValue(self))
+            .finish()
+    }
+}
+
+impl fmt::Display for Timestamp {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let Ok(ts) = jiff::Timestamp::try_from(self.time) else {
+            return Err(fmt::Error);
+        };
+
+        match self.precision {
+            TimestampPrecision::Seconds => write!(f, "{ts:.0}"),
+            TimestampPrecision::Millis => write!(f, "{ts:.3}"),
+            TimestampPrecision::Micros => write!(f, "{ts:.6}"),
+            TimestampPrecision::Nanos => write!(f, "{ts:.9}"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Timestamp;
+    use crate::TimestampPrecision;
+
+    #[test]
+    fn test_display_timestamp() {
+        let mut ts = Timestamp {
+            time: std::time::SystemTime::UNIX_EPOCH,
+            precision: TimestampPrecision::Nanos,
+        };
+
+        assert_eq!("1970-01-01T00:00:00.000000000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Micros;
+        assert_eq!("1970-01-01T00:00:00.000000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Millis;
+        assert_eq!("1970-01-01T00:00:00.000Z", format!("{ts}"));
+
+        ts.precision = TimestampPrecision::Seconds;
+        assert_eq!("1970-01-01T00:00:00Z", format!("{ts}"));
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/fmt/kv.rs

@@ -0,0 +1,69 @@
+use std::io::{self, Write};
+
+#[cfg(feature = "color")]
+use super::WriteStyle;
+use super::{Formatter, StyledValue};
+#[cfg(feature = "color")]
+use anstyle::Style;
+use log::kv::{Error, Key, Source, Value, VisitSource};
+
+/// Format function for serializing key/value pairs
+///
+/// This function determines how key/value pairs for structured logs are serialized within the default
+/// format.
+pub(crate) type KvFormatFn = dyn Fn(&mut Formatter, &dyn Source) -> io::Result<()> + Sync + Send;
+
+/// Null Key Value Format
+///
+/// This function is intended to be passed to
+/// [`Builder::format_key_values`](crate::Builder::format_key_values).
+///
+/// This key value format simply ignores any key/value fields and doesn't include them in the
+/// output.
+pub fn hidden_kv_format(_formatter: &mut Formatter, _fields: &dyn Source) -> io::Result<()> {
+    Ok(())
+}
+
+/// Default Key Value Format
+///
+/// This function is intended to be passed to
+/// [`Builder::format_key_values`](crate::Builder::format_key_values).
+///
+/// This is the default key/value format. Which uses an "=" as the separator between the key and
+/// value and a " " between each pair.
+///
+/// For example: `ip=127.0.0.1 port=123456 path=/example`
+pub fn default_kv_format(formatter: &mut Formatter, fields: &dyn Source) -> io::Result<()> {
+    fields
+        .visit(&mut DefaultVisitSource(formatter))
+        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+}
+
+struct DefaultVisitSource<'a>(&'a mut Formatter);
+
+impl<'kvs> VisitSource<'kvs> for DefaultVisitSource<'_> {
+    fn visit_pair(&mut self, key: Key<'_>, value: Value<'kvs>) -> Result<(), Error> {
+        write!(self.0, " {}={}", self.style_key(key), value)?;
+        Ok(())
+    }
+}
+
+impl DefaultVisitSource<'_> {
+    fn style_key<'k>(&self, text: Key<'k>) -> StyledValue<Key<'k>> {
+        #[cfg(feature = "color")]
+        {
+            StyledValue {
+                style: if self.0.write_style == WriteStyle::Never {
+                    Style::new()
+                } else {
+                    Style::new().italic()
+                },
+                value: text,
+            }
+        }
+        #[cfg(not(feature = "color"))]
+        {
+            text
+        }
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/fmt/mod.rs

@@ -0,0 +1,1002 @@
+//! Formatting for log records.
+//!
+//! This module contains a [`Formatter`] that can be used to format log records
+//! into without needing temporary allocations. Usually you won't need to worry
+//! about the contents of this module and can use the `Formatter` like an ordinary
+//! [`Write`].
+//!
+//! # Formatting log records
+//!
+//! The format used to print log records can be customised using the [`Builder::format`]
+//! method.
+//!
+//! Terminal styling is done through ANSI escape codes and will be adapted to the capabilities of
+//! the target stream.s
+//!
+//! For example, you could use one of:
+//! - [anstyle](https://docs.rs/anstyle) is a minimal, runtime string styling API and is re-exported as [`style`]
+//! - [owo-colors](https://docs.rs/owo-colors) is a feature rich runtime string styling API
+//! - [color-print](https://docs.rs/color-print) for feature-rich compile-time styling API
+//!
+//! See also [`Formatter::default_level_style`]
+//!
+//! ```
+//! use std::io::Write;
+//!
+//! let mut builder = env_logger::Builder::new();
+//!
+//! builder.format(|buf, record| {
+//!     writeln!(buf, "{}: {}",
+//!         record.level(),
+//!         record.args())
+//! });
+//! ```
+//!
+//! # Key Value arguments
+//!
+//! If the `kv` feature is enabled, then the default format will include key values from
+//! the log by default, but this can be disabled by calling [`Builder::format_key_values`]
+//! with [`hidden_kv_format`] as the format function.
+//!
+//! The way these keys and values are formatted can also be customized with a separate format
+//! function that is called by the default format with [`Builder::format_key_values`].
+//!
+//! ```
+//! # #[cfg(feature= "kv")]
+//! # {
+//! use log::info;
+//! env_logger::init();
+//! info!(x="45"; "Some message");
+//! info!(x="12"; "Another message {x}", x="12");
+//! # }
+//! ```
+//!
+//! See <https://docs.rs/log/latest/log/#structured-logging>.
+//!
+//! [`Builder::format`]: crate::Builder::format
+//! [`Write`]: std::io::Write
+//! [`Builder::format_key_values`]: crate::Builder::format_key_values
+
+use std::cell::RefCell;
+use std::fmt::Display;
+use std::io::prelude::Write;
+use std::rc::Rc;
+use std::{fmt, io, mem};
+
+#[cfg(feature = "color")]
+use log::Level;
+use log::Record;
+
+#[cfg(feature = "humantime")]
+mod humantime;
+#[cfg(feature = "kv")]
+mod kv;
+
+#[cfg(feature = "color")]
+pub use anstyle as style;
+
+#[cfg(feature = "humantime")]
+pub use self::humantime::Timestamp;
+#[cfg(feature = "kv")]
+pub use self::kv::*;
+pub use crate::writer::Target;
+pub use crate::writer::WriteStyle;
+
+use crate::writer::{Buffer, Writer};
+
+/// Formatting precision of timestamps.
+///
+/// Seconds give precision of full seconds, milliseconds give thousands of a
+/// second (3 decimal digits), microseconds are millionth of a second (6 decimal
+/// digits) and nanoseconds are billionth of a second (9 decimal digits).
+#[allow(clippy::exhaustive_enums)] // compatibility
+#[derive(Copy, Clone, Debug)]
+pub enum TimestampPrecision {
+    /// Full second precision (0 decimal digits)
+    Seconds,
+    /// Millisecond precision (3 decimal digits)
+    Millis,
+    /// Microsecond precision (6 decimal digits)
+    Micros,
+    /// Nanosecond precision (9 decimal digits)
+    Nanos,
+}
+
+/// The default timestamp precision is seconds.
+impl Default for TimestampPrecision {
+    fn default() -> Self {
+        TimestampPrecision::Seconds
+    }
+}
+
+/// A formatter to write logs into.
+///
+/// `Formatter` implements the standard [`Write`] trait for writing log records.
+/// It also supports terminal styling using ANSI escape codes.
+///
+/// # Examples
+///
+/// Use the [`writeln`] macro to format a log record.
+/// An instance of a `Formatter` is passed to an `env_logger` format as `buf`:
+///
+/// ```
+/// use std::io::Write;
+///
+/// let mut builder = env_logger::Builder::new();
+///
+/// builder.format(|buf, record| writeln!(buf, "{}: {}", record.level(), record.args()));
+/// ```
+///
+/// [`Write`]: std::io::Write
+/// [`writeln`]: std::writeln
+pub struct Formatter {
+    buf: Rc<RefCell<Buffer>>,
+    write_style: WriteStyle,
+}
+
+impl Formatter {
+    pub(crate) fn new(writer: &Writer) -> Self {
+        Formatter {
+            buf: Rc::new(RefCell::new(writer.buffer())),
+            write_style: writer.write_style(),
+        }
+    }
+
+    pub(crate) fn write_style(&self) -> WriteStyle {
+        self.write_style
+    }
+
+    pub(crate) fn print(&self, writer: &Writer) -> io::Result<()> {
+        writer.print(&self.buf.borrow())
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.buf.borrow_mut().clear();
+    }
+}
+
+#[cfg(feature = "color")]
+impl Formatter {
+    /// Get the default [`style::Style`] for the given level.
+    ///
+    /// The style can be used to print other values besides the level.
+    ///
+    /// See [`style`] for how to adapt it to the styling crate of your choice
+    pub fn default_level_style(&self, level: Level) -> style::Style {
+        if self.write_style == WriteStyle::Never {
+            style::Style::new()
+        } else {
+            match level {
+                Level::Trace => style::AnsiColor::Cyan.on_default(),
+                Level::Debug => style::AnsiColor::Blue.on_default(),
+                Level::Info => style::AnsiColor::Green.on_default(),
+                Level::Warn => style::AnsiColor::Yellow.on_default(),
+                Level::Error => style::AnsiColor::Red
+                    .on_default()
+                    .effects(style::Effects::BOLD),
+            }
+        }
+    }
+}
+
+impl Write for Formatter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buf.borrow_mut().write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buf.borrow_mut().flush()
+    }
+}
+
+impl fmt::Debug for Formatter {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let buf = self.buf.borrow();
+        f.debug_struct("Formatter")
+            .field("buf", &buf)
+            .field("write_style", &self.write_style)
+            .finish()
+    }
+}
+
+pub(crate) trait RecordFormat {
+    fn format(&self, formatter: &mut Formatter, record: &Record<'_>) -> io::Result<()>;
+}
+
+impl<F> RecordFormat for F
+where
+    F: Fn(&mut Formatter, &Record<'_>) -> io::Result<()>,
+{
+    fn format(&self, formatter: &mut Formatter, record: &Record<'_>) -> io::Result<()> {
+        (self)(formatter, record)
+    }
+}
+
+pub(crate) type FormatFn = Box<dyn RecordFormat + Sync + Send>;
+
+#[derive(Default)]
+pub(crate) struct Builder {
+    pub(crate) default_format: ConfigurableFormat,
+    pub(crate) custom_format: Option<FormatFn>,
+    built: bool,
+}
+
+impl Builder {
+    /// Convert the format into a callable function.
+    ///
+    /// If the `custom_format` is `Some`, then any `default_format` switches are ignored.
+    /// If the `custom_format` is `None`, then a default format is returned.
+    /// Any `default_format` switches set to `false` won't be written by the format.
+    pub(crate) fn build(&mut self) -> FormatFn {
+        assert!(!self.built, "attempt to re-use consumed builder");
+
+        let built = mem::replace(
+            self,
+            Builder {
+                built: true,
+                ..Default::default()
+            },
+        );
+
+        if let Some(fmt) = built.custom_format {
+            fmt
+        } else {
+            Box::new(built.default_format)
+        }
+    }
+}
+
+#[cfg(feature = "color")]
+type SubtleStyle = StyledValue<&'static str>;
+#[cfg(not(feature = "color"))]
+type SubtleStyle = &'static str;
+
+/// A value that can be printed using the given styles.
+#[cfg(feature = "color")]
+struct StyledValue<T> {
+    style: style::Style,
+    value: T,
+}
+
+#[cfg(feature = "color")]
+impl<T: Display> Display for StyledValue<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let style = self.style;
+
+        // We need to make sure `f`s settings don't get passed onto the styling but do get passed
+        // to the value
+        write!(f, "{style}")?;
+        self.value.fmt(f)?;
+        write!(f, "{style:#}")?;
+        Ok(())
+    }
+}
+
+#[cfg(not(feature = "color"))]
+type StyledValue<T> = T;
+
+/// A [custom format][crate::Builder::format] with settings for which fields to show
+pub struct ConfigurableFormat {
+    // This format needs to work with any combination of crate features.
+    pub(crate) timestamp: Option<TimestampPrecision>,
+    pub(crate) module_path: bool,
+    pub(crate) target: bool,
+    pub(crate) level: bool,
+    pub(crate) source_file: bool,
+    pub(crate) source_line_number: bool,
+    pub(crate) indent: Option<usize>,
+    pub(crate) suffix: &'static str,
+    #[cfg(feature = "kv")]
+    pub(crate) kv_format: Option<Box<KvFormatFn>>,
+}
+
+impl ConfigurableFormat {
+    /// Format the [`Record`] as configured for outputting
+    pub fn format(&self, formatter: &mut Formatter, record: &Record<'_>) -> io::Result<()> {
+        let fmt = ConfigurableFormatWriter {
+            format: self,
+            buf: formatter,
+            written_header_value: false,
+        };
+
+        fmt.write(record)
+    }
+}
+
+impl ConfigurableFormat {
+    /// Whether or not to write the level in the default format.
+    pub fn level(&mut self, write: bool) -> &mut Self {
+        self.level = write;
+        self
+    }
+
+    /// Whether or not to write the source file path in the default format.
+    pub fn file(&mut self, write: bool) -> &mut Self {
+        self.source_file = write;
+        self
+    }
+
+    /// Whether or not to write the source line number path in the default format.
+    ///
+    /// Only has effect if `format_file` is also enabled
+    pub fn line_number(&mut self, write: bool) -> &mut Self {
+        self.source_line_number = write;
+        self
+    }
+
+    /// Whether or not to write the module path in the default format.
+    pub fn module_path(&mut self, write: bool) -> &mut Self {
+        self.module_path = write;
+        self
+    }
+
+    /// Whether or not to write the target in the default format.
+    pub fn target(&mut self, write: bool) -> &mut Self {
+        self.target = write;
+        self
+    }
+
+    /// Configures the amount of spaces to use to indent multiline log records.
+    /// A value of `None` disables any kind of indentation.
+    pub fn indent(&mut self, indent: Option<usize>) -> &mut Self {
+        self.indent = indent;
+        self
+    }
+
+    /// Configures if timestamp should be included and in what precision.
+    pub fn timestamp(&mut self, timestamp: Option<TimestampPrecision>) -> &mut Self {
+        self.timestamp = timestamp;
+        self
+    }
+
+    /// Configures the end of line suffix.
+    pub fn suffix(&mut self, suffix: &'static str) -> &mut Self {
+        self.suffix = suffix;
+        self
+    }
+
+    /// Set the format for structured key/value pairs in the log record
+    ///
+    /// With the default format, this function is called for each record and should format
+    /// the structured key-value pairs as returned by [`log::Record::key_values`].
+    ///
+    /// The format function is expected to output the string directly to the `Formatter` so that
+    /// implementations can use the [`std::fmt`] macros, similar to the main format function.
+    ///
+    /// The default format uses a space to separate each key-value pair, with an "=" between
+    /// the key and value.
+    #[cfg(feature = "kv")]
+    pub fn key_values<F>(&mut self, format: F) -> &mut Self
+    where
+        F: Fn(&mut Formatter, &dyn log::kv::Source) -> io::Result<()> + Sync + Send + 'static,
+    {
+        self.kv_format = Some(Box::new(format));
+        self
+    }
+}
+
+impl Default for ConfigurableFormat {
+    fn default() -> Self {
+        Self {
+            timestamp: Some(Default::default()),
+            module_path: false,
+            target: true,
+            level: true,
+            source_file: false,
+            source_line_number: false,
+            indent: Some(4),
+            suffix: "\n",
+            #[cfg(feature = "kv")]
+            kv_format: None,
+        }
+    }
+}
+
+impl RecordFormat for ConfigurableFormat {
+    fn format(&self, formatter: &mut Formatter, record: &Record<'_>) -> io::Result<()> {
+        self.format(formatter, record)
+    }
+}
+
+/// The default format.
+///
+/// This format needs to work with any combination of crate features.
+struct ConfigurableFormatWriter<'a> {
+    format: &'a ConfigurableFormat,
+    buf: &'a mut Formatter,
+    written_header_value: bool,
+}
+
+impl ConfigurableFormatWriter<'_> {
+    fn write(mut self, record: &Record<'_>) -> io::Result<()> {
+        self.write_timestamp()?;
+        self.write_level(record)?;
+        self.write_module_path(record)?;
+        self.write_source_location(record)?;
+        self.write_target(record)?;
+        self.finish_header()?;
+
+        self.write_args(record)?;
+        #[cfg(feature = "kv")]
+        self.write_kv(record)?;
+        write!(self.buf, "{}", self.format.suffix)
+    }
+
+    fn subtle_style(&self, text: &'static str) -> SubtleStyle {
+        #[cfg(feature = "color")]
+        {
+            StyledValue {
+                style: if self.buf.write_style == WriteStyle::Never {
+                    style::Style::new()
+                } else {
+                    style::AnsiColor::BrightBlack.on_default()
+                },
+                value: text,
+            }
+        }
+        #[cfg(not(feature = "color"))]
+        {
+            text
+        }
+    }
+
+    fn write_header_value<T>(&mut self, value: T) -> io::Result<()>
+    where
+        T: Display,
+    {
+        if !self.written_header_value {
+            self.written_header_value = true;
+
+            let open_brace = self.subtle_style("[");
+            write!(self.buf, "{open_brace}{value}")
+        } else {
+            write!(self.buf, " {value}")
+        }
+    }
+
+    fn write_level(&mut self, record: &Record<'_>) -> io::Result<()> {
+        if !self.format.level {
+            return Ok(());
+        }
+
+        let level = {
+            let level = record.level();
+            #[cfg(feature = "color")]
+            {
+                StyledValue {
+                    style: self.buf.default_level_style(level),
+                    value: level,
+                }
+            }
+            #[cfg(not(feature = "color"))]
+            {
+                level
+            }
+        };
+
+        self.write_header_value(format_args!("{level:<5}"))
+    }
+
+    fn write_timestamp(&mut self) -> io::Result<()> {
+        #[cfg(feature = "humantime")]
+        {
+            use self::TimestampPrecision::{Micros, Millis, Nanos, Seconds};
+            let ts = match self.format.timestamp {
+                None => return Ok(()),
+                Some(Seconds) => self.buf.timestamp_seconds(),
+                Some(Millis) => self.buf.timestamp_millis(),
+                Some(Micros) => self.buf.timestamp_micros(),
+                Some(Nanos) => self.buf.timestamp_nanos(),
+            };
+
+            self.write_header_value(ts)
+        }
+        #[cfg(not(feature = "humantime"))]
+        {
+            // Trick the compiler to think we have used self.timestamp
+            // Workaround for "field is never used: `timestamp`" compiler nag.
+            let _ = self.format.timestamp;
+            Ok(())
+        }
+    }
+
+    fn write_module_path(&mut self, record: &Record<'_>) -> io::Result<()> {
+        if !self.format.module_path {
+            return Ok(());
+        }
+
+        if let Some(module_path) = record.module_path() {
+            self.write_header_value(module_path)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn write_source_location(&mut self, record: &Record<'_>) -> io::Result<()> {
+        if !self.format.source_file {
+            return Ok(());
+        }
+
+        if let Some(file_path) = record.file() {
+            let line = self
+                .format
+                .source_line_number
+                .then(|| record.line())
+                .flatten();
+            match line {
+                Some(line) => self.write_header_value(format_args!("{file_path}:{line}")),
+                None => self.write_header_value(file_path),
+            }
+        } else {
+            Ok(())
+        }
+    }
+
+    fn write_target(&mut self, record: &Record<'_>) -> io::Result<()> {
+        if !self.format.target {
+            return Ok(());
+        }
+
+        match record.target() {
+            "" => Ok(()),
+            target => self.write_header_value(target),
+        }
+    }
+
+    fn finish_header(&mut self) -> io::Result<()> {
+        if self.written_header_value {
+            let close_brace = self.subtle_style("]");
+            write!(self.buf, "{close_brace} ")
+        } else {
+            Ok(())
+        }
+    }
+
+    fn write_args(&mut self, record: &Record<'_>) -> io::Result<()> {
+        match self.format.indent {
+            // Fast path for no indentation
+            None => write!(self.buf, "{}", record.args()),
+
+            Some(indent_count) => {
+                // Create a wrapper around the buffer only if we have to actually indent the message
+
+                struct IndentWrapper<'a, 'b> {
+                    fmt: &'a mut ConfigurableFormatWriter<'b>,
+                    indent_count: usize,
+                }
+
+                impl Write for IndentWrapper<'_, '_> {
+                    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+                        let mut first = true;
+                        for chunk in buf.split(|&x| x == b'\n') {
+                            if !first {
+                                write!(
+                                    self.fmt.buf,
+                                    "{}{:width$}",
+                                    self.fmt.format.suffix,
+                                    "",
+                                    width = self.indent_count
+                                )?;
+                            }
+                            self.fmt.buf.write_all(chunk)?;
+                            first = false;
+                        }
+
+                        Ok(buf.len())
+                    }
+
+                    fn flush(&mut self) -> io::Result<()> {
+                        self.fmt.buf.flush()
+                    }
+                }
+
+                // The explicit scope here is just to make older versions of Rust happy
+                {
+                    let mut wrapper = IndentWrapper {
+                        fmt: self,
+                        indent_count,
+                    };
+                    write!(wrapper, "{}", record.args())?;
+                }
+
+                Ok(())
+            }
+        }
+    }
+
+    #[cfg(feature = "kv")]
+    fn write_kv(&mut self, record: &Record<'_>) -> io::Result<()> {
+        let format = self
+            .format
+            .kv_format
+            .as_deref()
+            .unwrap_or(&default_kv_format);
+        format(self.buf, record.key_values())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use log::{Level, Record};
+
+    fn write_record(record: Record<'_>, fmt: ConfigurableFormatWriter<'_>) -> String {
+        let buf = fmt.buf.buf.clone();
+
+        fmt.write(&record).expect("failed to write record");
+
+        let buf = buf.borrow();
+        String::from_utf8(buf.as_bytes().to_vec()).expect("failed to read record")
+    }
+
+    fn write_target(target: &str, fmt: ConfigurableFormatWriter<'_>) -> String {
+        write_record(
+            Record::builder()
+                .args(format_args!("log\nmessage"))
+                .level(Level::Info)
+                .file(Some("test.rs"))
+                .line(Some(144))
+                .module_path(Some("test::path"))
+                .target(target)
+                .build(),
+            fmt,
+        )
+    }
+
+    fn write(fmt: ConfigurableFormatWriter<'_>) -> String {
+        write_target("", fmt)
+    }
+
+    fn formatter() -> Formatter {
+        let writer = crate::writer::Builder::new()
+            .write_style(WriteStyle::Never)
+            .build();
+
+        Formatter::new(&writer)
+    }
+
+    #[test]
+    fn format_with_header() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: true,
+                target: false,
+                level: true,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: None,
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("[INFO  test::path] log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_no_header() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: false,
+                target: false,
+                level: false,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: None,
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_indent_spaces() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: true,
+                target: false,
+                level: true,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: Some(4),
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("[INFO  test::path] log\n    message\n", written);
+    }
+
+    #[test]
+    fn format_indent_zero_spaces() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: true,
+                target: false,
+                level: true,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: Some(0),
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("[INFO  test::path] log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_indent_spaces_no_header() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: false,
+                target: false,
+                level: false,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: Some(4),
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("log\n    message\n", written);
+    }
+
+    #[test]
+    fn format_suffix() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: false,
+                target: false,
+                level: false,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: None,
+                suffix: "\n\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("log\nmessage\n\n", written);
+    }
+
+    #[test]
+    fn format_suffix_with_indent() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: false,
+                target: false,
+                level: false,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: Some(4),
+                suffix: "\n\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("log\n\n    message\n\n", written);
+    }
+
+    #[test]
+    fn format_target() {
+        let mut f = formatter();
+
+        let written = write_target(
+            "target",
+            ConfigurableFormatWriter {
+                format: &ConfigurableFormat {
+                    timestamp: None,
+                    module_path: true,
+                    target: true,
+                    level: true,
+                    source_file: false,
+                    source_line_number: false,
+                    #[cfg(feature = "kv")]
+                    kv_format: Some(Box::new(hidden_kv_format)),
+                    indent: None,
+                    suffix: "\n",
+                },
+                written_header_value: false,
+                buf: &mut f,
+            },
+        );
+
+        assert_eq!("[INFO  test::path target] log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_empty_target() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: true,
+                target: true,
+                level: true,
+                source_file: false,
+                source_line_number: false,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: None,
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("[INFO  test::path] log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_no_target() {
+        let mut f = formatter();
+
+        let written = write_target(
+            "target",
+            ConfigurableFormatWriter {
+                format: &ConfigurableFormat {
+                    timestamp: None,
+                    module_path: true,
+                    target: false,
+                    level: true,
+                    source_file: false,
+                    source_line_number: false,
+                    #[cfg(feature = "kv")]
+                    kv_format: Some(Box::new(hidden_kv_format)),
+                    indent: None,
+                    suffix: "\n",
+                },
+                written_header_value: false,
+                buf: &mut f,
+            },
+        );
+
+        assert_eq!("[INFO  test::path] log\nmessage\n", written);
+    }
+
+    #[test]
+    fn format_with_source_file_and_line_number() {
+        let mut f = formatter();
+
+        let written = write(ConfigurableFormatWriter {
+            format: &ConfigurableFormat {
+                timestamp: None,
+                module_path: false,
+                target: false,
+                level: true,
+                source_file: true,
+                source_line_number: true,
+                #[cfg(feature = "kv")]
+                kv_format: Some(Box::new(hidden_kv_format)),
+                indent: None,
+                suffix: "\n",
+            },
+            written_header_value: false,
+            buf: &mut f,
+        });
+
+        assert_eq!("[INFO  test.rs:144] log\nmessage\n", written);
+    }
+
+    #[cfg(feature = "kv")]
+    #[test]
+    fn format_kv_default() {
+        let kvs = &[("a", 1u32), ("b", 2u32)][..];
+        let mut f = formatter();
+        let record = Record::builder()
+            .args(format_args!("log message"))
+            .level(Level::Info)
+            .module_path(Some("test::path"))
+            .key_values(&kvs)
+            .build();
+
+        let written = write_record(
+            record,
+            ConfigurableFormatWriter {
+                format: &ConfigurableFormat {
+                    timestamp: None,
+                    module_path: false,
+                    target: false,
+                    level: true,
+                    source_file: false,
+                    source_line_number: false,
+                    kv_format: Some(Box::new(default_kv_format)),
+                    indent: None,
+                    suffix: "\n",
+                },
+                written_header_value: false,
+                buf: &mut f,
+            },
+        );
+
+        assert_eq!("[INFO ] log message a=1 b=2\n", written);
+    }
+
+    #[cfg(feature = "kv")]
+    #[test]
+    fn format_kv_default_full() {
+        let kvs = &[("a", 1u32), ("b", 2u32)][..];
+        let mut f = formatter();
+        let record = Record::builder()
+            .args(format_args!("log\nmessage"))
+            .level(Level::Info)
+            .module_path(Some("test::path"))
+            .target("target")
+            .file(Some("test.rs"))
+            .line(Some(42))
+            .key_values(&kvs)
+            .build();
+
+        let written = write_record(
+            record,
+            ConfigurableFormatWriter {
+                format: &ConfigurableFormat {
+                    timestamp: None,
+                    module_path: true,
+                    target: true,
+                    level: true,
+                    source_file: true,
+                    source_line_number: true,
+                    kv_format: Some(Box::new(default_kv_format)),
+                    indent: None,
+                    suffix: "\n",
+                },
+                written_header_value: false,
+                buf: &mut f,
+            },
+        );
+
+        assert_eq!(
+            "[INFO  test::path test.rs:42 target] log\nmessage a=1 b=2\n",
+            written
+        );
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/lib.rs

@@ -0,0 +1,296 @@
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! A simple logger that can be configured via environment variables, for use
+//! with the logging facade exposed by the [`log` crate][log-crate-url].
+//!
+//! Despite having "env" in its name, **`env_logger`** can also be configured by
+//! other means besides environment variables. See [the examples][gh-repo-examples]
+//! in the source repository for more approaches.
+//!
+//! By default, `env_logger` writes logs to `stderr`, but can be configured to
+//! instead write them to `stdout`.
+//!
+//! ## Example
+//!
+//! ```
+//! use log::{debug, error, log_enabled, info, Level};
+//!
+//! env_logger::init();
+//!
+//! debug!("this is a debug {}", "message");
+//! error!("this is printed by default");
+//!
+//! if log_enabled!(Level::Info) {
+//!     let x = 3 * 4; // expensive computation
+//!     info!("the answer was: {}", x);
+//! }
+//! ```
+//!
+//! Assumes the binary is `main`:
+//!
+//! ```console
+//! $ RUST_LOG=error ./main
+//! [2017-11-09T02:12:24Z ERROR main] this is printed by default
+//! ```
+//!
+//! ```console
+//! $ RUST_LOG=info ./main
+//! [2017-11-09T02:12:24Z ERROR main] this is printed by default
+//! [2017-11-09T02:12:24Z INFO main] the answer was: 12
+//! ```
+//!
+//! ```console
+//! $ RUST_LOG=debug ./main
+//! [2017-11-09T02:12:24Z DEBUG main] this is a debug message
+//! [2017-11-09T02:12:24Z ERROR main] this is printed by default
+//! [2017-11-09T02:12:24Z INFO main] the answer was: 12
+//! ```
+//!
+//! You can also set the log level on a per module basis:
+//!
+//! ```console
+//! $ RUST_LOG=main=info ./main
+//! [2017-11-09T02:12:24Z ERROR main] this is printed by default
+//! [2017-11-09T02:12:24Z INFO main] the answer was: 12
+//! ```
+//!
+//! And enable all logging:
+//!
+//! ```console
+//! $ RUST_LOG=main ./main
+//! [2017-11-09T02:12:24Z DEBUG main] this is a debug message
+//! [2017-11-09T02:12:24Z ERROR main] this is printed by default
+//! [2017-11-09T02:12:24Z INFO main] the answer was: 12
+//! ```
+//!
+//! If the binary name contains hyphens, you will need to replace
+//! them with underscores:
+//!
+//! ```console
+//! $ RUST_LOG=my_app ./my-app
+//! [2017-11-09T02:12:24Z DEBUG my_app] this is a debug message
+//! [2017-11-09T02:12:24Z ERROR my_app] this is printed by default
+//! [2017-11-09T02:12:24Z INFO my_app] the answer was: 12
+//! ```
+//!
+//! This is because Rust modules and crates cannot contain hyphens
+//! in their name, although `cargo` continues to accept them.
+//!
+//! See the documentation for the [`log` crate][log-crate-url] for more
+//! information about its API.
+//!
+//! ## Enabling logging
+//!
+//! **By default all logging is disabled except for the `error` level**
+//!
+//! The **`RUST_LOG`** environment variable controls logging with the syntax:
+//! ```console
+//! RUST_LOG=[target][=][level][,...]
+//! ```
+//! Or in other words, its a comma-separated list of directives.
+//! Directives can filter by **target**, by **level**, or both (using `=`).
+//!
+//! For example,
+//! ```console
+//! RUST_LOG=data=debug,hardware=debug
+//! ```
+//!
+//! **target** is typically the path of the module the message
+//! in question originated from, though it can be overridden.
+//! The path is rooted in the name of the crate it was compiled for, so if
+//! your program is in a file called, for example, `hello.rs`, the path would
+//! simply be `hello`.
+//!
+//! Furthermore, the log can be filtered using prefix-search based on the
+//! specified log target.
+//!
+//! For example, `RUST_LOG=example` would match the following targets:
+//! - `example`
+//! - `example::test`
+//! - `example::test::module::submodule`
+//! - `examples::and_more_examples`
+//!
+//! When providing the crate name or a module path, explicitly specifying the
+//! log level is optional. If omitted, all logging for the item will be
+//! enabled.
+//!
+//! **level** is the maximum [`log::Level`][level-enum] to be shown and includes:
+//! - `error`
+//! - `warn`
+//! - `info`
+//! - `debug`
+//! - `trace`
+//! - `off` (pseudo level to disable all logging for the target)
+//!
+//! Logging level names are case-insensitive; e.g.,
+//! `debug`, `DEBUG`, and `dEbuG` all represent the same logging level. For
+//! consistency, our convention is to use the lower case names. Where our docs
+//! do use other forms, they do so in the context of specific examples, so you
+//! won't be surprised if you see similar usage in the wild.
+//!
+//! Some examples of valid values of `RUST_LOG` are:
+//!
+//! - `RUST_LOG=hello` turns on all logging for the `hello` module
+//! - `RUST_LOG=trace` turns on all logging for the application, regardless of its name
+//! - `RUST_LOG=TRACE` turns on all logging for the application, regardless of its name (same as previous)
+//! - `RUST_LOG=info` turns on all info logging
+//! - `RUST_LOG=INFO` turns on all info logging (same as previous)
+//! - `RUST_LOG=hello=debug` turns on debug logging for `hello`
+//! - `RUST_LOG=hello=DEBUG` turns on debug logging for `hello` (same as previous)
+//! - `RUST_LOG=hello,std::option` turns on `hello`, and std's option logging
+//! - `RUST_LOG=error,hello=warn` turn on global error logging and also warn for `hello`
+//! - `RUST_LOG=error,hello=off`  turn on global error logging, but turn off logging for `hello`
+//! - `RUST_LOG=off` turns off all logging for the application
+//! - `RUST_LOG=OFF` turns off all logging for the application (same as previous)
+//!
+//! ## Filtering results
+//!
+//! A `RUST_LOG` directive may include a regex filter. The syntax is to append `/`
+//! followed by a regex. Each message is checked against the regex, and is only
+//! logged if it matches. Note that the matching is done after formatting the
+//! log string but before adding any logging meta-data. There is a single filter
+//! for all modules.
+//!
+//! Some examples:
+//!
+//! * `hello/foo` turns on all logging for the 'hello' module where the log
+//!   message includes 'foo'.
+//! * `info/f.o` turns on all info logging where the log message includes 'foo',
+//!   'f1o', 'fao', etc.
+//! * `hello=debug/foo*foo` turns on debug logging for 'hello' where the log
+//!   message includes 'foofoo' or 'fofoo' or 'fooooooofoo', etc.
+//! * `error,hello=warn/[0-9]scopes` turn on global error logging and also
+//!   warn for hello. In both cases the log message must include a single digit
+//!   number followed by 'scopes'.
+//!
+//! ## Capturing logs in tests
+//!
+//! Records logged during `cargo test` will not be captured by the test harness by default.
+//! The [`Builder::is_test`] method can be used in unit tests to ensure logs will be captured:
+//!
+//! ```test_harness
+//! #[cfg(test)]
+//! mod tests {
+//!     use log::info;
+//!
+//!     fn init() {
+//!         let _ = env_logger::builder().is_test(true).try_init();
+//!     }
+//!
+//!     #[test]
+//!     fn it_works() {
+//!         init();
+//!
+//!         info!("This record will be captured by `cargo test`");
+//!
+//!         assert_eq!(2, 1 + 1);
+//!     }
+//! }
+//! ```
+//!
+//! Enabling test capturing comes at the expense of color and other style support
+//! and may have performance implications.
+//!
+//! ## Colors
+//!
+//! Outputting of colors and other styles can be controlled by the `RUST_LOG_STYLE`
+//! environment variable. It accepts the following [values][fmt::WriteStyle]:
+//!
+//! * `auto` (default) will attempt to print style characters, but don't force the issue.
+//!   If the console isn't available on Windows, or if TERM=dumb, for example, then don't print colors.
+//! * `always` will always print style characters even if they aren't supported by the terminal.
+//!   This includes emitting ANSI colors on Windows if the console API is unavailable.
+//! * `never` will never print style characters.
+//!
+//! Color may be applied in the logged message or a [custom formatter][fmt].
+//!
+//! <div class="warning">
+//!
+//! Logging of untrusted inputs can cause unexpected behavior as they may include ANSI escape codes which
+//! will be forwarded to the users terminal as part of "Weaponizing ANSI Escape Sequences".
+//!
+//! Mitigations include:
+//! - Setting `RUST_LOG_STYLE=never` to have all ANSI escape codes stripped
+//! - In the application, calling [`Builder::write_style(Never)`][Builder::write_style] to have all ANSI escape codes stripped
+//! - In the application, [stripping ANSI escape codes](https://docs.rs/anstream/latest/anstream/adapter/fn.strip_str.html)
+//!   from user inputs
+//!
+//! Note: deactivating the build-time feature `color` is not a mitigation as that removes all ANSI escape code
+//! stripping from `env_logger`.
+//!
+//! </div>
+//!
+//! ## Tweaking the default format
+//!
+//! Parts of the default format can be excluded from the log output using the [`Builder`].
+//! The following example excludes the timestamp from the log output:
+//!
+//! ```
+//! env_logger::builder()
+//!     .format_timestamp(None)
+//!     .init();
+//! ```
+//!
+//! ### Stability of the default format
+//!
+//! The default format won't optimise for long-term stability, and explicitly makes no
+//! guarantees about the stability of its output across major, minor or patch version
+//! bumps during `0.x`.
+//!
+//! If you want to capture or interpret the output of `env_logger` programmatically
+//! then you should use a custom format.
+//!
+//! ### Using a custom format
+//!
+//! Custom formats can be provided as closures to the [`Builder`].
+//! These closures take a [`Formatter`][crate::fmt::Formatter] and `log::Record` as arguments:
+//!
+//! ```
+//! use std::io::Write;
+//!
+//! env_logger::builder()
+//!     .format(|buf, record| {
+//!         writeln!(buf, "{}: {}", record.level(), record.args())
+//!     })
+//!     .init();
+//! ```
+//!
+//! See the [`fmt`] module for more details about custom formats.
+//!
+//! ## Specifying defaults for environment variables
+//!
+//! `env_logger` can read configuration from environment variables.
+//! If these variables aren't present, the default value to use can be tweaked with the [`Env`] type.
+//! The following example defaults to log `warn` and above if the `RUST_LOG` environment variable
+//! isn't set:
+//!
+//! ```
+//! use env_logger::Env;
+//!
+//! env_logger::Builder::from_env(Env::default().default_filter_or("warn")).init();
+//! ```
+//!
+//! [gh-repo-examples]: https://github.com/rust-cli/env_logger/tree/main/examples
+//! [level-enum]: https://docs.rs/log/latest/log/enum.Level.html
+//! [log-crate-url]: https://docs.rs/log
+
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![warn(clippy::print_stderr)]
+#![warn(clippy::print_stdout)]
+#![allow(clippy::test_attr_in_doctest)]
+
+mod logger;
+mod writer;
+
+pub mod fmt;
+
+pub use self::fmt::{Target, TimestampPrecision, WriteStyle};
+pub use self::logger::*;
+
+#[doc = include_str!("../README.md")]
+#[cfg(doctest)]
+pub struct ReadmeDoctests;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/logger.rs

@@ -0,0 +1,1058 @@
+use std::{borrow::Cow, cell::RefCell, env, io};
+
+use log::{LevelFilter, Log, Metadata, Record, SetLoggerError};
+
+use crate::fmt;
+use crate::fmt::{FormatFn, Formatter};
+use crate::writer::{self, Writer};
+
+/// The default name for the environment variable to read filters from.
+pub const DEFAULT_FILTER_ENV: &str = "RUST_LOG";
+
+/// The default name for the environment variable to read style preferences from.
+pub const DEFAULT_WRITE_STYLE_ENV: &str = "RUST_LOG_STYLE";
+
+/// `Builder` acts as builder for initializing a `Logger`.
+///
+/// It can be used to customize the log format, change the environment variable used
+/// to provide the logging directives and also set the default log level filter.
+///
+/// # Examples
+///
+/// ```
+/// # use std::io::Write;
+/// use env_logger::Builder;
+/// use log::{LevelFilter, error, info};
+///
+/// let mut builder = Builder::from_default_env();
+///
+/// builder
+///     .format(|buf, record| writeln!(buf, "{} - {}", record.level(), record.args()))
+///     .filter(None, LevelFilter::Info)
+///     .init();
+///
+/// error!("error message");
+/// info!("info message");
+/// ```
+#[derive(Default)]
+pub struct Builder {
+    filter: env_filter::Builder,
+    writer: writer::Builder,
+    format: fmt::Builder,
+    built: bool,
+}
+
+impl Builder {
+    /// Initializes the log builder with defaults.
+    ///
+    /// **NOTE:** This method won't read from any environment variables.
+    /// Use the [`filter`] and [`write_style`] methods to configure the builder
+    /// or use [`from_env`] or [`from_default_env`] instead.
+    ///
+    /// # Examples
+    ///
+    /// Create a new builder and configure filters and style:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::{Builder, WriteStyle};
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder
+    ///     .filter(None, LevelFilter::Info)
+    ///     .write_style(WriteStyle::Always)
+    ///     .init();
+    /// ```
+    ///
+    /// [`filter`]: #method.filter
+    /// [`write_style`]: #method.write_style
+    /// [`from_env`]: #method.from_env
+    /// [`from_default_env`]: #method.from_default_env
+    pub fn new() -> Builder {
+        Default::default()
+    }
+
+    /// Initializes the log builder from the environment.
+    ///
+    /// The variables used to read configuration from can be tweaked before
+    /// passing in.
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger reading the log filter from an environment variable
+    /// called `MY_LOG`:
+    ///
+    /// ```
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::from_env("MY_LOG");
+    /// builder.init();
+    /// ```
+    ///
+    /// Initialise a logger using the `MY_LOG` variable for filtering and
+    /// `MY_LOG_STYLE` for whether or not to write styles:
+    ///
+    /// ```
+    /// use env_logger::{Builder, Env};
+    ///
+    /// let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");
+    ///
+    /// let mut builder = Builder::from_env(env);
+    /// builder.init();
+    /// ```
+    pub fn from_env<'a, E>(env: E) -> Self
+    where
+        E: Into<Env<'a>>,
+    {
+        let mut builder = Builder::new();
+        builder.parse_env(env);
+        builder
+    }
+
+    /// Applies the configuration from the environment.
+    ///
+    /// This function allows a builder to be configured with default parameters,
+    /// to be then overridden by the environment.
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger with filter level `Off`, then override the log
+    /// filter from an environment variable called `MY_LOG`:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_env("MY_LOG");
+    /// builder.init();
+    /// ```
+    ///
+    /// Initialise a logger with filter level `Off`, then use the `MY_LOG`
+    /// variable to override filtering and `MY_LOG_STYLE` to override  whether
+    /// or not to write styles:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::{Builder, Env};
+    ///
+    /// let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");
+    ///
+    /// let mut builder = Builder::new();
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_env(env);
+    /// builder.init();
+    /// ```
+    pub fn parse_env<'a, E>(&mut self, env: E) -> &mut Self
+    where
+        E: Into<Env<'a>>,
+    {
+        let env = env.into();
+
+        if let Some(s) = env.get_filter() {
+            self.parse_filters(&s);
+        }
+
+        if let Some(s) = env.get_write_style() {
+            self.parse_write_style(&s);
+        }
+
+        self
+    }
+
+    /// Initializes the log builder from the environment using default variable names.
+    ///
+    /// This method is a convenient way to call `from_env(Env::default())` without
+    /// having to use the `Env` type explicitly. The builder will use the
+    /// [default environment variables].
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger using the default environment variables:
+    ///
+    /// ```
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::from_default_env();
+    /// builder.init();
+    /// ```
+    ///
+    /// [default environment variables]: struct.Env.html#default-environment-variables
+    pub fn from_default_env() -> Self {
+        Self::from_env(Env::default())
+    }
+
+    /// Applies the configuration from the environment using default variable names.
+    ///
+    /// This method is a convenient way to call `parse_env(Env::default())` without
+    /// having to use the `Env` type explicitly. The builder will use the
+    /// [default environment variables].
+    ///
+    /// # Examples
+    ///
+    /// Initialise a logger with filter level `Off`, then configure it using the
+    /// default environment variables:
+    ///
+    /// ```
+    /// use log::LevelFilter;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    /// builder.filter_level(LevelFilter::Off);
+    /// builder.parse_default_env();
+    /// builder.init();
+    /// ```
+    ///
+    /// [default environment variables]: struct.Env.html#default-environment-variables
+    pub fn parse_default_env(&mut self) -> &mut Self {
+        self.parse_env(Env::default())
+    }
+
+    /// Sets the format function for formatting the log output.
+    ///
+    /// This function is called on each record logged and should format the
+    /// log record and output it to the given [`Formatter`].
+    ///
+    /// The format function is expected to output the string directly to the
+    /// `Formatter` so that implementations can use the [`std::fmt`] macros
+    /// to format and output without intermediate heap allocations. The default
+    /// `env_logger` formatter takes advantage of this.
+    ///
+    /// When the `color` feature is enabled, styling via ANSI escape codes is supported and the
+    /// output will automatically respect [`Builder::write_style`].
+    ///
+    /// # Examples
+    ///
+    /// Use a custom format to write only the log message:
+    ///
+    /// ```
+    /// use std::io::Write;
+    /// use env_logger::Builder;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.format(|buf, record| writeln!(buf, "{}", record.args()));
+    /// ```
+    ///
+    /// [`Formatter`]: fmt/struct.Formatter.html
+    /// [`String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
+    /// [`std::fmt`]: https://doc.rust-lang.org/std/fmt/index.html
+    pub fn format<F>(&mut self, format: F) -> &mut Self
+    where
+        F: Fn(&mut Formatter, &Record<'_>) -> io::Result<()> + Sync + Send + 'static,
+    {
+        self.format.custom_format = Some(Box::new(format));
+        self
+    }
+
+    /// Use the default format.
+    ///
+    /// This method will clear any custom format set on the builder.
+    pub fn default_format(&mut self) -> &mut Self {
+        self.format = Default::default();
+        self
+    }
+
+    /// Whether or not to write the level in the default format.
+    pub fn format_level(&mut self, write: bool) -> &mut Self {
+        self.format.default_format.level(write);
+        self
+    }
+
+    /// Whether or not to write the source file path in the default format.
+    pub fn format_file(&mut self, write: bool) -> &mut Self {
+        self.format.default_format.file(write);
+        self
+    }
+
+    /// Whether or not to write the source line number path in the default format.
+    ///
+    /// Only has effect if `format_file` is also enabled
+    pub fn format_line_number(&mut self, write: bool) -> &mut Self {
+        self.format.default_format.line_number(write);
+        self
+    }
+
+    /// Whether or not to write the source path and line number
+    ///
+    /// Equivalent to calling both `format_file` and `format_line_number`
+    /// with `true`
+    pub fn format_source_path(&mut self, write: bool) -> &mut Self {
+        self.format_file(write).format_line_number(write);
+        self
+    }
+
+    /// Whether or not to write the module path in the default format.
+    pub fn format_module_path(&mut self, write: bool) -> &mut Self {
+        self.format.default_format.module_path(write);
+        self
+    }
+
+    /// Whether or not to write the target in the default format.
+    pub fn format_target(&mut self, write: bool) -> &mut Self {
+        self.format.default_format.target(write);
+        self
+    }
+
+    /// Configures the amount of spaces to use to indent multiline log records.
+    /// A value of `None` disables any kind of indentation.
+    pub fn format_indent(&mut self, indent: Option<usize>) -> &mut Self {
+        self.format.default_format.indent(indent);
+        self
+    }
+
+    /// Configures if timestamp should be included and in what precision.
+    pub fn format_timestamp(&mut self, timestamp: Option<fmt::TimestampPrecision>) -> &mut Self {
+        self.format.default_format.timestamp(timestamp);
+        self
+    }
+
+    /// Configures the timestamp to use second precision.
+    pub fn format_timestamp_secs(&mut self) -> &mut Self {
+        self.format_timestamp(Some(fmt::TimestampPrecision::Seconds))
+    }
+
+    /// Configures the timestamp to use millisecond precision.
+    pub fn format_timestamp_millis(&mut self) -> &mut Self {
+        self.format_timestamp(Some(fmt::TimestampPrecision::Millis))
+    }
+
+    /// Configures the timestamp to use microsecond precision.
+    pub fn format_timestamp_micros(&mut self) -> &mut Self {
+        self.format_timestamp(Some(fmt::TimestampPrecision::Micros))
+    }
+
+    /// Configures the timestamp to use nanosecond precision.
+    pub fn format_timestamp_nanos(&mut self) -> &mut Self {
+        self.format_timestamp(Some(fmt::TimestampPrecision::Nanos))
+    }
+
+    /// Configures the end of line suffix.
+    pub fn format_suffix(&mut self, suffix: &'static str) -> &mut Self {
+        self.format.default_format.suffix(suffix);
+        self
+    }
+
+    /// Set the format for structured key/value pairs in the log record
+    ///
+    /// With the default format, this function is called for each record and should format
+    /// the structured key-value pairs as returned by [`log::Record::key_values`].
+    ///
+    /// The format function is expected to output the string directly to the `Formatter` so that
+    /// implementations can use the [`std::fmt`] macros, similar to the main format function.
+    ///
+    /// The default format uses a space to separate each key-value pair, with an "=" between
+    /// the key and value.
+    #[cfg(feature = "kv")]
+    pub fn format_key_values<F>(&mut self, format: F) -> &mut Self
+    where
+        F: Fn(&mut Formatter, &dyn log::kv::Source) -> io::Result<()> + Sync + Send + 'static,
+    {
+        self.format.default_format.key_values(format);
+        self
+    }
+
+    /// Adds a directive to the filter for a specific module.
+    ///
+    /// # Examples
+    ///
+    /// Only include messages for info and above for logs in `path::to::module`:
+    ///
+    /// ```
+    /// use env_logger::Builder;
+    /// use log::LevelFilter;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.filter_module("path::to::module", LevelFilter::Info);
+    /// ```
+    pub fn filter_module(&mut self, module: &str, level: LevelFilter) -> &mut Self {
+        self.filter.filter_module(module, level);
+        self
+    }
+
+    /// Adds a directive to the filter for all modules.
+    ///
+    /// # Examples
+    ///
+    /// Only include messages for info and above for logs globally:
+    ///
+    /// ```
+    /// use env_logger::Builder;
+    /// use log::LevelFilter;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.filter_level(LevelFilter::Info);
+    /// ```
+    pub fn filter_level(&mut self, level: LevelFilter) -> &mut Self {
+        self.filter.filter_level(level);
+        self
+    }
+
+    /// Adds filters to the logger.
+    ///
+    /// The given module (if any) will log at most the specified level provided.
+    /// If no module is provided then the filter will apply to all log messages.
+    ///
+    /// # Examples
+    ///
+    /// Only include messages for info and above for logs in `path::to::module`:
+    ///
+    /// ```
+    /// use env_logger::Builder;
+    /// use log::LevelFilter;
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.filter(Some("path::to::module"), LevelFilter::Info);
+    /// ```
+    pub fn filter(&mut self, module: Option<&str>, level: LevelFilter) -> &mut Self {
+        self.filter.filter(module, level);
+        self
+    }
+
+    /// Parses the directives string in the same form as the `RUST_LOG`
+    /// environment variable.
+    ///
+    /// See the module documentation for more details.
+    pub fn parse_filters(&mut self, filters: &str) -> &mut Self {
+        self.filter.parse(filters);
+        self
+    }
+
+    /// Sets the target for the log output.
+    ///
+    /// Env logger can log to either stdout, stderr or a custom pipe. The default is stderr.
+    ///
+    /// The custom pipe can be used to send the log messages to a custom sink (for example a file).
+    /// Do note that direct writes to a file can become a bottleneck due to IO operation times.
+    ///
+    /// # Examples
+    ///
+    /// Write log message to `stdout`:
+    ///
+    /// ```
+    /// use env_logger::{Builder, Target};
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.target(Target::Stdout);
+    /// ```
+    pub fn target(&mut self, target: fmt::Target) -> &mut Self {
+        self.writer.target(target);
+        self
+    }
+
+    /// Sets whether or not styles will be written.
+    ///
+    /// This can be useful in environments that don't support control characters
+    /// for setting colors.
+    ///
+    /// # Examples
+    ///
+    /// Never attempt to write styles:
+    ///
+    /// ```
+    /// use env_logger::{Builder, WriteStyle};
+    ///
+    /// let mut builder = Builder::new();
+    ///
+    /// builder.write_style(WriteStyle::Never);
+    /// ```
+    pub fn write_style(&mut self, write_style: fmt::WriteStyle) -> &mut Self {
+        self.writer.write_style(write_style);
+        self
+    }
+
+    /// Parses whether or not to write styles in the same form as the `RUST_LOG_STYLE`
+    /// environment variable.
+    ///
+    /// See the module documentation for more details.
+    pub fn parse_write_style(&mut self, write_style: &str) -> &mut Self {
+        self.writer.parse_write_style(write_style);
+        self
+    }
+
+    /// Sets whether or not the logger will be used in unit tests.
+    ///
+    /// If `is_test` is `true` then the logger will allow the testing framework to
+    /// capture log records rather than printing them to the terminal directly.
+    pub fn is_test(&mut self, is_test: bool) -> &mut Self {
+        self.writer.is_test(is_test);
+        self
+    }
+
+    /// Initializes the global logger with the built env logger.
+    ///
+    /// This should be called early in the execution of a Rust program. Any log
+    /// events that occur before initialization will be ignored.
+    ///
+    /// # Errors
+    ///
+    /// This function will fail if it is called more than once, or if another
+    /// library has already initialized a global logger.
+    pub fn try_init(&mut self) -> Result<(), SetLoggerError> {
+        let logger = self.build();
+
+        let max_level = logger.filter();
+        let r = log::set_boxed_logger(Box::new(logger));
+
+        if r.is_ok() {
+            log::set_max_level(max_level);
+        }
+
+        r
+    }
+
+    /// Initializes the global logger with the built env logger.
+    ///
+    /// This should be called early in the execution of a Rust program. Any log
+    /// events that occur before initialization will be ignored.
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if it is called more than once, or if another
+    /// library has already initialized a global logger.
+    pub fn init(&mut self) {
+        self.try_init()
+            .expect("Builder::init should not be called after logger initialized");
+    }
+
+    /// Build an env logger.
+    ///
+    /// The returned logger implements the `Log` trait and can be installed manually
+    /// or nested within another logger.
+    pub fn build(&mut self) -> Logger {
+        assert!(!self.built, "attempt to re-use consumed builder");
+        self.built = true;
+
+        Logger {
+            writer: self.writer.build(),
+            filter: self.filter.build(),
+            format: self.format.build(),
+        }
+    }
+}
+
+impl std::fmt::Debug for Builder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.built {
+            f.debug_struct("Logger").field("built", &true).finish()
+        } else {
+            f.debug_struct("Logger")
+                .field("filter", &self.filter)
+                .field("writer", &self.writer)
+                .finish()
+        }
+    }
+}
+
+/// The env logger.
+///
+/// This struct implements the `Log` trait from the [`log` crate][log-crate-url],
+/// which allows it to act as a logger.
+///
+/// The [`init()`], [`try_init()`], [`Builder::init()`] and [`Builder::try_init()`]
+/// methods will each construct a `Logger` and immediately initialize it as the
+/// default global logger.
+///
+/// If you'd instead need access to the constructed `Logger`, you can use
+/// the associated [`Builder`] and install it with the
+/// [`log` crate][log-crate-url] directly.
+///
+/// [log-crate-url]: https://docs.rs/log
+/// [`init()`]: fn.init.html
+/// [`try_init()`]: fn.try_init.html
+/// [`Builder::init()`]: struct.Builder.html#method.init
+/// [`Builder::try_init()`]: struct.Builder.html#method.try_init
+/// [`Builder`]: struct.Builder.html
+pub struct Logger {
+    writer: Writer,
+    filter: env_filter::Filter,
+    format: FormatFn,
+}
+
+impl Logger {
+    /// Creates the logger from the environment.
+    ///
+    /// The variables used to read configuration from can be tweaked before
+    /// passing in.
+    ///
+    /// # Examples
+    ///
+    /// Create a logger reading the log filter from an environment variable
+    /// called `MY_LOG`:
+    ///
+    /// ```
+    /// use env_logger::Logger;
+    ///
+    /// let logger = Logger::from_env("MY_LOG");
+    /// ```
+    ///
+    /// Create a logger using the `MY_LOG` variable for filtering and
+    /// `MY_LOG_STYLE` for whether or not to write styles:
+    ///
+    /// ```
+    /// use env_logger::{Logger, Env};
+    ///
+    /// let env = Env::new().filter_or("MY_LOG", "info").write_style_or("MY_LOG_STYLE", "always");
+    ///
+    /// let logger = Logger::from_env(env);
+    /// ```
+    pub fn from_env<'a, E>(env: E) -> Self
+    where
+        E: Into<Env<'a>>,
+    {
+        Builder::from_env(env).build()
+    }
+
+    /// Creates the logger from the environment using default variable names.
+    ///
+    /// This method is a convenient way to call `from_env(Env::default())` without
+    /// having to use the `Env` type explicitly. The logger will use the
+    /// [default environment variables].
+    ///
+    /// # Examples
+    ///
+    /// Creates a logger using the default environment variables:
+    ///
+    /// ```
+    /// use env_logger::Logger;
+    ///
+    /// let logger = Logger::from_default_env();
+    /// ```
+    ///
+    /// [default environment variables]: struct.Env.html#default-environment-variables
+    pub fn from_default_env() -> Self {
+        Builder::from_default_env().build()
+    }
+
+    /// Returns the maximum `LevelFilter` that this env logger instance is
+    /// configured to output.
+    pub fn filter(&self) -> LevelFilter {
+        self.filter.filter()
+    }
+
+    /// Checks if this record matches the configured filter.
+    pub fn matches(&self, record: &Record<'_>) -> bool {
+        self.filter.matches(record)
+    }
+}
+
+impl Log for Logger {
+    fn enabled(&self, metadata: &Metadata<'_>) -> bool {
+        self.filter.enabled(metadata)
+    }
+
+    fn log(&self, record: &Record<'_>) {
+        if self.matches(record) {
+            // Log records are written to a thread-local buffer before being printed
+            // to the terminal. We clear these buffers afterwards, but they aren't shrunk
+            // so will always at least have capacity for the largest log record formatted
+            // on that thread.
+            //
+            // If multiple `Logger`s are used by the same threads then the thread-local
+            // formatter might have different color support. If this is the case the
+            // formatter and its buffer are discarded and recreated.
+
+            thread_local! {
+                static FORMATTER: RefCell<Option<Formatter>> = const { RefCell::new(None) };
+            }
+
+            let print = |formatter: &mut Formatter, record: &Record<'_>| {
+                let _ = self
+                    .format
+                    .format(formatter, record)
+                    .and_then(|_| formatter.print(&self.writer));
+
+                // Always clear the buffer afterwards
+                formatter.clear();
+            };
+
+            let printed = FORMATTER
+                .try_with(|tl_buf| {
+                    if let Ok(mut tl_buf) = tl_buf.try_borrow_mut() {
+                        // There are no active borrows of the buffer
+                        if let Some(ref mut formatter) = *tl_buf {
+                            // We have a previously set formatter
+
+                            // Check the buffer style. If it's different from the logger's
+                            // style then drop the buffer and recreate it.
+                            if formatter.write_style() != self.writer.write_style() {
+                                *formatter = Formatter::new(&self.writer);
+                            }
+
+                            print(formatter, record);
+                        } else {
+                            // We don't have a previously set formatter
+                            let mut formatter = Formatter::new(&self.writer);
+                            print(&mut formatter, record);
+
+                            *tl_buf = Some(formatter);
+                        }
+                    } else {
+                        // There's already an active borrow of the buffer (due to re-entrancy)
+                        print(&mut Formatter::new(&self.writer), record);
+                    }
+                })
+                .is_ok();
+
+            if !printed {
+                // The thread-local storage was not available (because its
+                // destructor has already run). Create a new single-use
+                // Formatter on the stack for this call.
+                print(&mut Formatter::new(&self.writer), record);
+            }
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+impl std::fmt::Debug for Logger {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Logger")
+            .field("filter", &self.filter)
+            .finish()
+    }
+}
+
+/// Set of environment variables to configure from.
+///
+/// # Default environment variables
+///
+/// By default, the `Env` will read the following environment variables:
+///
+/// - `RUST_LOG`: the level filter
+/// - `RUST_LOG_STYLE`: whether or not to print styles with records.
+///
+/// These sources can be configured using the builder methods on `Env`.
+#[derive(Debug)]
+pub struct Env<'a> {
+    filter: Var<'a>,
+    write_style: Var<'a>,
+}
+
+impl<'a> Env<'a> {
+    /// Get a default set of environment variables.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Specify an environment variable to read the filter from.
+    pub fn filter<E>(mut self, filter_env: E) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+    {
+        self.filter = Var::new(filter_env);
+
+        self
+    }
+
+    /// Specify an environment variable to read the filter from.
+    ///
+    /// If the variable is not set, the default value will be used.
+    pub fn filter_or<E, V>(mut self, filter_env: E, default: V) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+        V: Into<Cow<'a, str>>,
+    {
+        self.filter = Var::new_with_default(filter_env, default);
+
+        self
+    }
+
+    /// Use the default environment variable to read the filter from.
+    ///
+    /// If the variable is not set, the default value will be used.
+    pub fn default_filter_or<V>(mut self, default: V) -> Self
+    where
+        V: Into<Cow<'a, str>>,
+    {
+        self.filter = Var::new_with_default(DEFAULT_FILTER_ENV, default);
+
+        self
+    }
+
+    fn get_filter(&self) -> Option<String> {
+        self.filter.get()
+    }
+
+    /// Specify an environment variable to read the style from.
+    pub fn write_style<E>(mut self, write_style_env: E) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+    {
+        self.write_style = Var::new(write_style_env);
+
+        self
+    }
+
+    /// Specify an environment variable to read the style from.
+    ///
+    /// If the variable is not set, the default value will be used.
+    pub fn write_style_or<E, V>(mut self, write_style_env: E, default: V) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+        V: Into<Cow<'a, str>>,
+    {
+        self.write_style = Var::new_with_default(write_style_env, default);
+
+        self
+    }
+
+    /// Use the default environment variable to read the style from.
+    ///
+    /// If the variable is not set, the default value will be used.
+    pub fn default_write_style_or<V>(mut self, default: V) -> Self
+    where
+        V: Into<Cow<'a, str>>,
+    {
+        self.write_style = Var::new_with_default(DEFAULT_WRITE_STYLE_ENV, default);
+
+        self
+    }
+
+    fn get_write_style(&self) -> Option<String> {
+        self.write_style.get()
+    }
+}
+
+impl<'a, T> From<T> for Env<'a>
+where
+    T: Into<Cow<'a, str>>,
+{
+    fn from(filter_env: T) -> Self {
+        Env::default().filter(filter_env.into())
+    }
+}
+
+impl Default for Env<'_> {
+    fn default() -> Self {
+        Env {
+            filter: Var::new(DEFAULT_FILTER_ENV),
+            write_style: Var::new(DEFAULT_WRITE_STYLE_ENV),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Var<'a> {
+    name: Cow<'a, str>,
+    default: Option<Cow<'a, str>>,
+}
+
+impl<'a> Var<'a> {
+    fn new<E>(name: E) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+    {
+        Var {
+            name: name.into(),
+            default: None,
+        }
+    }
+
+    fn new_with_default<E, V>(name: E, default: V) -> Self
+    where
+        E: Into<Cow<'a, str>>,
+        V: Into<Cow<'a, str>>,
+    {
+        Var {
+            name: name.into(),
+            default: Some(default.into()),
+        }
+    }
+
+    fn get(&self) -> Option<String> {
+        env::var(&*self.name)
+            .ok()
+            .or_else(|| self.default.clone().map(|v| v.into_owned()))
+    }
+}
+
+/// Attempts to initialize the global logger with an env logger.
+///
+/// This should be called early in the execution of a Rust program. Any log
+/// events that occur before initialization will be ignored.
+///
+/// # Errors
+///
+/// This function will fail if it is called more than once, or if another
+/// library has already initialized a global logger.
+pub fn try_init() -> Result<(), SetLoggerError> {
+    try_init_from_env(Env::default())
+}
+
+/// Initializes the global logger with an env logger.
+///
+/// This should be called early in the execution of a Rust program. Any log
+/// events that occur before initialization will be ignored.
+///
+/// # Panics
+///
+/// This function will panic if it is called more than once, or if another
+/// library has already initialized a global logger.
+pub fn init() {
+    try_init().expect("env_logger::init should not be called after logger initialized");
+}
+
+/// Attempts to initialize the global logger with an env logger from the given
+/// environment variables.
+///
+/// This should be called early in the execution of a Rust program. Any log
+/// events that occur before initialization will be ignored.
+///
+/// # Examples
+///
+/// Initialise a logger using the `MY_LOG` environment variable for filters
+/// and `MY_LOG_STYLE` for writing colors:
+///
+/// ```
+/// use env_logger::{Builder, Env};
+///
+/// # fn run() -> Result<(), Box<dyn ::std::error::Error>> {
+/// let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");
+///
+/// env_logger::try_init_from_env(env)?;
+///
+/// Ok(())
+/// # }
+/// # run().unwrap();
+/// ```
+///
+/// # Errors
+///
+/// This function will fail if it is called more than once, or if another
+/// library has already initialized a global logger.
+pub fn try_init_from_env<'a, E>(env: E) -> Result<(), SetLoggerError>
+where
+    E: Into<Env<'a>>,
+{
+    let mut builder = Builder::from_env(env);
+
+    builder.try_init()
+}
+
+/// Initializes the global logger with an env logger from the given environment
+/// variables.
+///
+/// This should be called early in the execution of a Rust program. Any log
+/// events that occur before initialization will be ignored.
+///
+/// # Examples
+///
+/// Initialise a logger using the `MY_LOG` environment variable for filters
+/// and `MY_LOG_STYLE` for writing colors:
+///
+/// ```
+/// use env_logger::{Builder, Env};
+///
+/// let env = Env::new().filter("MY_LOG").write_style("MY_LOG_STYLE");
+///
+/// env_logger::init_from_env(env);
+/// ```
+///
+/// # Panics
+///
+/// This function will panic if it is called more than once, or if another
+/// library has already initialized a global logger.
+pub fn init_from_env<'a, E>(env: E)
+where
+    E: Into<Env<'a>>,
+{
+    try_init_from_env(env)
+        .expect("env_logger::init_from_env should not be called after logger initialized");
+}
+
+/// Create a new builder with the default environment variables.
+///
+/// The builder can be configured before being initialized.
+/// This is a convenient way of calling [`Builder::from_default_env`].
+///
+/// [`Builder::from_default_env`]: struct.Builder.html#method.from_default_env
+pub fn builder() -> Builder {
+    Builder::from_default_env()
+}
+
+/// Create a builder from the given environment variables.
+///
+/// The builder can be configured before being initialized.
+#[deprecated(
+    since = "0.8.0",
+    note = "Prefer `env_logger::Builder::from_env()` instead."
+)]
+pub fn from_env<'a, E>(env: E) -> Builder
+where
+    E: Into<Env<'a>>,
+{
+    Builder::from_env(env)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn env_get_filter_reads_from_var_if_set() {
+        env::set_var("env_get_filter_reads_from_var_if_set", "from var");
+
+        let env = Env::new().filter_or("env_get_filter_reads_from_var_if_set", "from default");
+
+        assert_eq!(Some("from var".to_owned()), env.get_filter());
+    }
+
+    #[test]
+    fn env_get_filter_reads_from_default_if_var_not_set() {
+        env::remove_var("env_get_filter_reads_from_default_if_var_not_set");
+
+        let env = Env::new().filter_or(
+            "env_get_filter_reads_from_default_if_var_not_set",
+            "from default",
+        );
+
+        assert_eq!(Some("from default".to_owned()), env.get_filter());
+    }
+
+    #[test]
+    fn env_get_write_style_reads_from_var_if_set() {
+        env::set_var("env_get_write_style_reads_from_var_if_set", "from var");
+
+        let env =
+            Env::new().write_style_or("env_get_write_style_reads_from_var_if_set", "from default");
+
+        assert_eq!(Some("from var".to_owned()), env.get_write_style());
+    }
+
+    #[test]
+    fn env_get_write_style_reads_from_default_if_var_not_set() {
+        env::remove_var("env_get_write_style_reads_from_default_if_var_not_set");
+
+        let env = Env::new().write_style_or(
+            "env_get_write_style_reads_from_default_if_var_not_set",
+            "from default",
+        );
+
+        assert_eq!(Some("from default".to_owned()), env.get_write_style());
+    }
+
+    #[test]
+    fn builder_parse_env_overrides_existing_filters() {
+        env::set_var(
+            "builder_parse_default_env_overrides_existing_filters",
+            "debug",
+        );
+        let env = Env::new().filter("builder_parse_default_env_overrides_existing_filters");
+
+        let mut builder = Builder::new();
+        builder.filter_level(LevelFilter::Trace);
+        // Overrides global level to debug
+        builder.parse_env(env);
+
+        assert_eq!(builder.filter.build().filter(), LevelFilter::Debug);
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/env_logger-0.11.9/src/writer/buffer.rs

@@ -0,0 +1,175 @@
+use std::{io, sync::Mutex};
+
+use crate::writer::WriteStyle;
+
+#[derive(Debug)]
+pub(crate) struct BufferWriter {
+    target: WritableTarget,
+    write_style: WriteStyle,
+}
+
+impl BufferWriter {
+    pub(crate) fn stderr(is_test: bool, write_style: WriteStyle) -> Self {
+        BufferWriter {
+            target: if is_test {
+                WritableTarget::PrintStderr
+            } else {
+                WritableTarget::WriteStderr
+            },
+            write_style,
+        }
+    }
+
+    pub(crate) fn stdout(is_test: bool, write_style: WriteStyle) -> Self {
+        BufferWriter {
+            target: if is_test {
+                WritableTarget::PrintStdout
+            } else {
+                WritableTarget::WriteStdout
+            },
+            write_style,
+        }
+    }
+
+    pub(crate) fn pipe(
+        pipe: Box<Mutex<dyn io::Write + Send + 'static>>,
+        write_style: WriteStyle,
+    ) -> Self {
+        BufferWriter {
+            target: WritableTarget::Pipe(pipe),
+            write_style,
+        }
+    }
+
+    pub(crate) fn write_style(&self) -> WriteStyle {
+        self.write_style
+    }
+
+    pub(crate) fn buffer(&self) -> Buffer {
+        Buffer(Vec::new())
+    }
+
+    pub(crate) fn print(&self, buf: &Buffer) -> io::Result<()> {
+        #![allow(clippy::print_stdout)] // enabled for tests only
+        #![allow(clippy::print_stderr)] // enabled for tests only
+
+        use std::io::Write as _;
+
+        let buf = buf.as_bytes();
+        match &self.target {
+            WritableTarget::WriteStdout => {
+                let stream = io::stdout();
+                #[cfg(feature = "color")]
+                let stream = anstream::AutoStream::new(stream, self.write_style.into());
+                let mut stream = stream.lock();
+                stream.write_all(buf)?;
+                stream.flush()?;
+            }
+            WritableTarget::PrintStdout => {
+                #[cfg(feature = "color")]
+                let buf = adapt(buf, self.write_style)?;
+                #[cfg(feature = "color")]
+                let buf = &buf;
+                let buf = String::from_utf8_lossy(buf);
+                print!("{buf}");
+            }
+            WritableTarget::WriteStderr => {
+                let stream = io::stderr();
+                #[cfg(feature = "color")]
+                let stream = anstream::AutoStream::new(stream, self.write_style.into());
+                let mut stream = stream.lock();
+                stream.write_all(buf)?;
+                stream.flush()?;
+            }
+            WritableTarget::PrintStderr => {
+                #[cfg(feature = "color")]
+                let buf = adapt(buf, self.write_style)?;
+                #[cfg(feature = "color")]
+                let buf = &buf;
+                let buf = String::from_utf8_lossy(buf);
+                eprint!("{buf}");
+            }
+            WritableTarget::Pipe(pipe) => {
+                #[cfg(feature = "color")]
+                let buf = adapt(buf, self.write_style)?;
+                #[cfg(feature = "color")]
+                let buf = &buf;
+                let mut stream = pipe.lock().expect("no panics while held");
+                stream.write_all(buf)?;
+                stream.flush()?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(feature = "color")]
+fn adapt(buf: &[u8], write_style: WriteStyle) -> io::Result<Vec<u8>> {
+    use std::io::Write as _;
+
+    let adapted = Vec::with_capacity(buf.len());
+    let mut stream = anstream::AutoStream::new(adapted, write_style.into());
+    stream.write_all(buf)?;
+    let adapted = stream.into_inner();
+    Ok(adapted)
+}
+
+pub(crate) struct Buffer(Vec<u8>);
+
+impl Buffer {
+    pub(crate) fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    pub(crate) fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.0.extend(buf);
+        Ok(buf.len())
+    }
+
+    pub(crate) fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+
+    pub(crate) fn as_bytes(&self) -> &[u8] {
+        &self.0
+    }
+}
+
+impl std::fmt::Debug for Buffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        String::from_utf8_lossy(self.as_bytes()).fmt(f)
+    }
+}
+
+/// Log target, either `stdout`, `stderr` or a custom pipe.
+///
+/// Same as `Target`, except the pipe is wrapped in a mutex for interior mutability.
+pub(crate) enum WritableTarget {
+    /// Logs will be written to standard output.
+    WriteStdout,
+    /// Logs will be printed to standard output.
+    PrintStdout,
+    /// Logs will be written to standard error.
+    WriteStderr,
+    /// Logs will be printed to standard error.
+    PrintStderr,
+    /// Logs will be sent to a custom pipe.
+    Pipe(Box<Mutex<dyn io::Write + Send + 'static>>),
+}
+
+impl std::fmt::Debug for WritableTarget {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            match self {
+                Self::WriteStdout => "stdout",
+                Self::PrintStdout => "stdout",
+                Self::WriteStderr => "stderr",
+                Self::PrintStderr => "stderr",
+                Self::Pipe(_) => "pipe",
+            }
+        )
+    }
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/arm/mempolicy.rs

@@ -0,0 +1,175 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const EPERM: u32 = 1;
+pub const ENOENT: u32 = 2;
+pub const ESRCH: u32 = 3;
+pub const EINTR: u32 = 4;
+pub const EIO: u32 = 5;
+pub const ENXIO: u32 = 6;
+pub const E2BIG: u32 = 7;
+pub const ENOEXEC: u32 = 8;
+pub const EBADF: u32 = 9;
+pub const ECHILD: u32 = 10;
+pub const EAGAIN: u32 = 11;
+pub const ENOMEM: u32 = 12;
+pub const EACCES: u32 = 13;
+pub const EFAULT: u32 = 14;
+pub const ENOTBLK: u32 = 15;
+pub const EBUSY: u32 = 16;
+pub const EEXIST: u32 = 17;
+pub const EXDEV: u32 = 18;
+pub const ENODEV: u32 = 19;
+pub const ENOTDIR: u32 = 20;
+pub const EISDIR: u32 = 21;
+pub const EINVAL: u32 = 22;
+pub const ENFILE: u32 = 23;
+pub const EMFILE: u32 = 24;
+pub const ENOTTY: u32 = 25;
+pub const ETXTBSY: u32 = 26;
+pub const EFBIG: u32 = 27;
+pub const ENOSPC: u32 = 28;
+pub const ESPIPE: u32 = 29;
+pub const EROFS: u32 = 30;
+pub const EMLINK: u32 = 31;
+pub const EPIPE: u32 = 32;
+pub const EDOM: u32 = 33;
+pub const ERANGE: u32 = 34;
+pub const EDEADLK: u32 = 35;
+pub const ENAMETOOLONG: u32 = 36;
+pub const ENOLCK: u32 = 37;
+pub const ENOSYS: u32 = 38;
+pub const ENOTEMPTY: u32 = 39;
+pub const ELOOP: u32 = 40;
+pub const EWOULDBLOCK: u32 = 11;
+pub const ENOMSG: u32 = 42;
+pub const EIDRM: u32 = 43;
+pub const ECHRNG: u32 = 44;
+pub const EL2NSYNC: u32 = 45;
+pub const EL3HLT: u32 = 46;
+pub const EL3RST: u32 = 47;
+pub const ELNRNG: u32 = 48;
+pub const EUNATCH: u32 = 49;
+pub const ENOCSI: u32 = 50;
+pub const EL2HLT: u32 = 51;
+pub const EBADE: u32 = 52;
+pub const EBADR: u32 = 53;
+pub const EXFULL: u32 = 54;
+pub const ENOANO: u32 = 55;
+pub const EBADRQC: u32 = 56;
+pub const EBADSLT: u32 = 57;
+pub const EDEADLOCK: u32 = 35;
+pub const EBFONT: u32 = 59;
+pub const ENOSTR: u32 = 60;
+pub const ENODATA: u32 = 61;
+pub const ETIME: u32 = 62;
+pub const ENOSR: u32 = 63;
+pub const ENONET: u32 = 64;
+pub const ENOPKG: u32 = 65;
+pub const EREMOTE: u32 = 66;
+pub const ENOLINK: u32 = 67;
+pub const EADV: u32 = 68;
+pub const ESRMNT: u32 = 69;
+pub const ECOMM: u32 = 70;
+pub const EPROTO: u32 = 71;
+pub const EMULTIHOP: u32 = 72;
+pub const EDOTDOT: u32 = 73;
+pub const EBADMSG: u32 = 74;
+pub const EOVERFLOW: u32 = 75;
+pub const ENOTUNIQ: u32 = 76;
+pub const EBADFD: u32 = 77;
+pub const EREMCHG: u32 = 78;
+pub const ELIBACC: u32 = 79;
+pub const ELIBBAD: u32 = 80;
+pub const ELIBSCN: u32 = 81;
+pub const ELIBMAX: u32 = 82;
+pub const ELIBEXEC: u32 = 83;
+pub const EILSEQ: u32 = 84;
+pub const ERESTART: u32 = 85;
+pub const ESTRPIPE: u32 = 86;
+pub const EUSERS: u32 = 87;
+pub const ENOTSOCK: u32 = 88;
+pub const EDESTADDRREQ: u32 = 89;
+pub const EMSGSIZE: u32 = 90;
+pub const EPROTOTYPE: u32 = 91;
+pub const ENOPROTOOPT: u32 = 92;
+pub const EPROTONOSUPPORT: u32 = 93;
+pub const ESOCKTNOSUPPORT: u32 = 94;
+pub const EOPNOTSUPP: u32 = 95;
+pub const EPFNOSUPPORT: u32 = 96;
+pub const EAFNOSUPPORT: u32 = 97;
+pub const EADDRINUSE: u32 = 98;
+pub const EADDRNOTAVAIL: u32 = 99;
+pub const ENETDOWN: u32 = 100;
+pub const ENETUNREACH: u32 = 101;
+pub const ENETRESET: u32 = 102;
+pub const ECONNABORTED: u32 = 103;
+pub const ECONNRESET: u32 = 104;
+pub const ENOBUFS: u32 = 105;
+pub const EISCONN: u32 = 106;
+pub const ENOTCONN: u32 = 107;
+pub const ESHUTDOWN: u32 = 108;
+pub const ETOOMANYREFS: u32 = 109;
+pub const ETIMEDOUT: u32 = 110;
+pub const ECONNREFUSED: u32 = 111;
+pub const EHOSTDOWN: u32 = 112;
+pub const EHOSTUNREACH: u32 = 113;
+pub const EALREADY: u32 = 114;
+pub const EINPROGRESS: u32 = 115;
+pub const ESTALE: u32 = 116;
+pub const EUCLEAN: u32 = 117;
+pub const ENOTNAM: u32 = 118;
+pub const ENAVAIL: u32 = 119;
+pub const EISNAM: u32 = 120;
+pub const EREMOTEIO: u32 = 121;
+pub const EDQUOT: u32 = 122;
+pub const ENOMEDIUM: u32 = 123;
+pub const EMEDIUMTYPE: u32 = 124;
+pub const ECANCELED: u32 = 125;
+pub const ENOKEY: u32 = 126;
+pub const EKEYEXPIRED: u32 = 127;
+pub const EKEYREVOKED: u32 = 128;
+pub const EKEYREJECTED: u32 = 129;
+pub const EOWNERDEAD: u32 = 130;
+pub const ENOTRECOVERABLE: u32 = 131;
+pub const ERFKILL: u32 = 132;
+pub const EHWPOISON: u32 = 133;
+pub const MPOL_F_STATIC_NODES: u32 = 32768;
+pub const MPOL_F_RELATIVE_NODES: u32 = 16384;
+pub const MPOL_F_NUMA_BALANCING: u32 = 8192;
+pub const MPOL_MODE_FLAGS: u32 = 57344;
+pub const MPOL_F_NODE: u32 = 1;
+pub const MPOL_F_ADDR: u32 = 2;
+pub const MPOL_F_MEMS_ALLOWED: u32 = 4;
+pub const MPOL_MF_STRICT: u32 = 1;
+pub const MPOL_MF_MOVE: u32 = 2;
+pub const MPOL_MF_MOVE_ALL: u32 = 4;
+pub const MPOL_MF_LAZY: u32 = 8;
+pub const MPOL_MF_INTERNAL: u32 = 16;
+pub const MPOL_MF_VALID: u32 = 7;
+pub const MPOL_F_SHARED: u32 = 1;
+pub const MPOL_F_MOF: u32 = 8;
+pub const MPOL_F_MORON: u32 = 16;
+pub const RECLAIM_ZONE: u32 = 1;
+pub const RECLAIM_WRITE: u32 = 2;
+pub const RECLAIM_UNMAP: u32 = 4;
+pub const MPOL_DEFAULT: _bindgen_ty_1 = _bindgen_ty_1::MPOL_DEFAULT;
+pub const MPOL_PREFERRED: _bindgen_ty_1 = _bindgen_ty_1::MPOL_PREFERRED;
+pub const MPOL_BIND: _bindgen_ty_1 = _bindgen_ty_1::MPOL_BIND;
+pub const MPOL_INTERLEAVE: _bindgen_ty_1 = _bindgen_ty_1::MPOL_INTERLEAVE;
+pub const MPOL_LOCAL: _bindgen_ty_1 = _bindgen_ty_1::MPOL_LOCAL;
+pub const MPOL_PREFERRED_MANY: _bindgen_ty_1 = _bindgen_ty_1::MPOL_PREFERRED_MANY;
+pub const MPOL_WEIGHTED_INTERLEAVE: _bindgen_ty_1 = _bindgen_ty_1::MPOL_WEIGHTED_INTERLEAVE;
+pub const MPOL_MAX: _bindgen_ty_1 = _bindgen_ty_1::MPOL_MAX;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+MPOL_DEFAULT = 0,
+MPOL_PREFERRED = 1,
+MPOL_BIND = 2,
+MPOL_INTERLEAVE = 3,
+MPOL_LOCAL = 4,
+MPOL_PREFERRED_MANY = 5,
+MPOL_WEIGHTED_INTERLEAVE = 6,
+MPOL_MAX = 7,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/arm/xdp.rs

@@ -0,0 +1,191 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_mode_t = crate::ctypes::c_ushort;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_ushort;
+pub type __kernel_uid_t = crate::ctypes::c_ushort;
+pub type __kernel_gid_t = crate::ctypes::c_ushort;
+pub type __kernel_old_dev_t = crate::ctypes::c_ushort;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_xdp {
+pub sxdp_family: __u16,
+pub sxdp_flags: __u16,
+pub sxdp_ifindex: __u32,
+pub sxdp_queue_id: __u32,
+pub sxdp_shared_umem_fd: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_ring_offset {
+pub producer: __u64,
+pub consumer: __u64,
+pub desc: __u64,
+pub flags: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_mmap_offsets {
+pub rx: xdp_ring_offset,
+pub tx: xdp_ring_offset,
+pub fr: xdp_ring_offset,
+pub cr: xdp_ring_offset,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_umem_reg {
+pub addr: __u64,
+pub len: __u64,
+pub chunk_size: __u32,
+pub headroom: __u32,
+pub flags: __u32,
+pub tx_metadata_len: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_statistics {
+pub rx_dropped: __u64,
+pub rx_invalid_descs: __u64,
+pub tx_invalid_descs: __u64,
+pub rx_ring_full: __u64,
+pub rx_fill_ring_empty_descs: __u64,
+pub tx_ring_empty_descs: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_options {
+pub flags: __u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct xsk_tx_metadata {
+pub flags: __u64,
+pub __bindgen_anon_1: xsk_tx_metadata__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xsk_tx_metadata__bindgen_ty_1__bindgen_ty_1 {
+pub csum_start: __u16,
+pub csum_offset: __u16,
+pub launch_time: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xsk_tx_metadata__bindgen_ty_1__bindgen_ty_2 {
+pub tx_timestamp: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_desc {
+pub addr: __u64,
+pub len: __u32,
+pub options: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_ring_offset_v1 {
+pub producer: __u64,
+pub consumer: __u64,
+pub desc: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_mmap_offsets_v1 {
+pub rx: xdp_ring_offset_v1,
+pub tx: xdp_ring_offset_v1,
+pub fr: xdp_ring_offset_v1,
+pub cr: xdp_ring_offset_v1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_umem_reg_v1 {
+pub addr: __u64,
+pub len: __u64,
+pub chunk_size: __u32,
+pub headroom: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_statistics_v1 {
+pub rx_dropped: __u64,
+pub rx_invalid_descs: __u64,
+pub tx_invalid_descs: __u64,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const XDP_SHARED_UMEM: u32 = 1;
+pub const XDP_COPY: u32 = 2;
+pub const XDP_ZEROCOPY: u32 = 4;
+pub const XDP_USE_NEED_WAKEUP: u32 = 8;
+pub const XDP_USE_SG: u32 = 16;
+pub const XDP_UMEM_UNALIGNED_CHUNK_FLAG: u32 = 1;
+pub const XDP_UMEM_TX_SW_CSUM: u32 = 2;
+pub const XDP_UMEM_TX_METADATA_LEN: u32 = 4;
+pub const XDP_RING_NEED_WAKEUP: u32 = 1;
+pub const XDP_MMAP_OFFSETS: u32 = 1;
+pub const XDP_RX_RING: u32 = 2;
+pub const XDP_TX_RING: u32 = 3;
+pub const XDP_UMEM_REG: u32 = 4;
+pub const XDP_UMEM_FILL_RING: u32 = 5;
+pub const XDP_UMEM_COMPLETION_RING: u32 = 6;
+pub const XDP_STATISTICS: u32 = 7;
+pub const XDP_OPTIONS: u32 = 8;
+pub const XDP_OPTIONS_ZEROCOPY: u32 = 1;
+pub const XDP_PGOFF_RX_RING: u32 = 0;
+pub const XDP_PGOFF_TX_RING: u32 = 2147483648;
+pub const XDP_UMEM_PGOFF_FILL_RING: u64 = 4294967296;
+pub const XDP_UMEM_PGOFF_COMPLETION_RING: u64 = 6442450944;
+pub const XSK_UNALIGNED_BUF_OFFSET_SHIFT: u32 = 48;
+pub const XSK_UNALIGNED_BUF_ADDR_MASK: u64 = 281474976710655;
+pub const XDP_TXMD_FLAGS_TIMESTAMP: u32 = 1;
+pub const XDP_TXMD_FLAGS_CHECKSUM: u32 = 2;
+pub const XDP_TXMD_FLAGS_LAUNCH_TIME: u32 = 4;
+pub const XDP_PKT_CONTD: u32 = 1;
+pub const XDP_TX_METADATA: u32 = 2;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union xsk_tx_metadata__bindgen_ty_1 {
+pub request: xsk_tx_metadata__bindgen_ty_1__bindgen_ty_1,
+pub completion: xsk_tx_metadata__bindgen_ty_1__bindgen_ty_2,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/auxvec.rs

@@ -0,0 +1,30 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const AT_NULL: u32 = 0;
+pub const AT_IGNORE: u32 = 1;
+pub const AT_EXECFD: u32 = 2;
+pub const AT_PHDR: u32 = 3;
+pub const AT_PHENT: u32 = 4;
+pub const AT_PHNUM: u32 = 5;
+pub const AT_PAGESZ: u32 = 6;
+pub const AT_BASE: u32 = 7;
+pub const AT_FLAGS: u32 = 8;
+pub const AT_ENTRY: u32 = 9;
+pub const AT_NOTELF: u32 = 10;
+pub const AT_UID: u32 = 11;
+pub const AT_EUID: u32 = 12;
+pub const AT_GID: u32 = 13;
+pub const AT_EGID: u32 = 14;
+pub const AT_PLATFORM: u32 = 15;
+pub const AT_HWCAP: u32 = 16;
+pub const AT_CLKTCK: u32 = 17;
+pub const AT_SECURE: u32 = 23;
+pub const AT_BASE_PLATFORM: u32 = 24;
+pub const AT_RANDOM: u32 = 25;
+pub const AT_HWCAP2: u32 = 26;
+pub const AT_RSEQ_FEATURE_SIZE: u32 = 27;
+pub const AT_RSEQ_ALIGN: u32 = 28;
+pub const AT_HWCAP3: u32 = 29;
+pub const AT_HWCAP4: u32 = 30;
+pub const AT_EXECFN: u32 = 31;
+pub const AT_MINSIGSTKSZ: u32 = 51;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/bootparam.rs

@@ -0,0 +1,3 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/btrfs.rs

@@ -0,0 +1,1894 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type __kernel_rwf_t = crate::ctypes::c_int;
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v1 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub master_key_descriptor: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_key {
+pub mode: __u32,
+pub raw: [__u8; 64usize],
+pub size: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v2 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub log2_data_unit_size: __u8,
+pub __reserved: [__u8; 3usize],
+pub master_key_identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_policy_ex_arg {
+pub policy_size: __u64,
+pub policy: fscrypt_get_policy_ex_arg__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_key_specifier {
+pub type_: __u32,
+pub __reserved: __u32,
+pub u: fscrypt_key_specifier__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct fscrypt_provisioning_key_payload {
+pub type_: __u32,
+pub flags: __u32,
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+pub struct fscrypt_add_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub raw_size: __u32,
+pub key_id: __u32,
+pub flags: __u32,
+pub __reserved: [__u32; 7usize],
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_remove_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub removal_status_flags: __u32,
+pub __reserved: [__u32; 5usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_key_status_arg {
+pub key_spec: fscrypt_key_specifier,
+pub __reserved: [__u32; 6usize],
+pub status: __u32,
+pub status_flags: __u32,
+pub user_count: __u32,
+pub __out_reserved: [__u32; 13usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mount_attr {
+pub attr_set: __u64,
+pub attr_clr: __u64,
+pub propagation: __u64,
+pub userns_fd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct statmount {
+pub size: __u32,
+pub mnt_opts: __u32,
+pub mask: __u64,
+pub sb_dev_major: __u32,
+pub sb_dev_minor: __u32,
+pub sb_magic: __u64,
+pub sb_flags: __u32,
+pub fs_type: __u32,
+pub mnt_id: __u64,
+pub mnt_parent_id: __u64,
+pub mnt_id_old: __u32,
+pub mnt_parent_id_old: __u32,
+pub mnt_attr: __u64,
+pub mnt_propagation: __u64,
+pub mnt_peer_group: __u64,
+pub mnt_master: __u64,
+pub propagate_from: __u64,
+pub mnt_root: __u32,
+pub mnt_point: __u32,
+pub mnt_ns_id: __u64,
+pub fs_subtype: __u32,
+pub sb_source: __u32,
+pub opt_num: __u32,
+pub opt_array: __u32,
+pub opt_sec_num: __u32,
+pub opt_sec_array: __u32,
+pub supported_mask: __u64,
+pub mnt_uidmap_num: __u32,
+pub mnt_uidmap: __u32,
+pub mnt_gidmap_num: __u32,
+pub mnt_gidmap: __u32,
+pub __spare2: [__u64; 43usize],
+pub str_: __IncompleteArrayField<crate::ctypes::c_char>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mnt_id_req {
+pub size: __u32,
+pub spare: __u32,
+pub mnt_id: __u64,
+pub param: __u64,
+pub mnt_ns_id: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_clone_range {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fstrim_range {
+pub start: __u64,
+pub len: __u64,
+pub minlen: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsuuid2 {
+pub len: __u8,
+pub uuid: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fs_sysfs_path {
+pub len: __u8,
+pub name: [__u8; 128usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_dedupe_range_info {
+pub dest_fd: __s64,
+pub dest_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct file_dedupe_range {
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<file_dedupe_range_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct files_stat_struct {
+pub nr_files: crate::ctypes::c_ulong,
+pub nr_free_files: crate::ctypes::c_ulong,
+pub max_files: crate::ctypes::c_ulong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct inodes_stat_t {
+pub nr_inodes: crate::ctypes::c_long,
+pub nr_unused: crate::ctypes::c_long,
+pub dummy: [crate::ctypes::c_long; 5usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsxattr {
+pub fsx_xflags: __u32,
+pub fsx_extsize: __u32,
+pub fsx_nextents: __u32,
+pub fsx_projid: __u32,
+pub fsx_cowextsize: __u32,
+pub fsx_pad: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct page_region {
+pub start: __u64,
+pub end: __u64,
+pub categories: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct pm_scan_arg {
+pub size: __u64,
+pub flags: __u64,
+pub start: __u64,
+pub end: __u64,
+pub walk_end: __u64,
+pub vec: __u64,
+pub vec_len: __u64,
+pub max_pages: __u64,
+pub category_inverted: __u64,
+pub category_mask: __u64,
+pub category_anyof_mask: __u64,
+pub return_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct procmap_query {
+pub size: __u64,
+pub query_flags: __u64,
+pub query_addr: __u64,
+pub vma_start: __u64,
+pub vma_end: __u64,
+pub vma_flags: __u64,
+pub vma_page_size: __u64,
+pub vma_offset: __u64,
+pub inode: __u64,
+pub dev_major: __u32,
+pub dev_minor: __u32,
+pub vma_name_size: __u32,
+pub build_id_size: __u32,
+pub vma_name_addr: __u64,
+pub build_id_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_vol_args {
+pub fd: __s64,
+pub name: [crate::ctypes::c_char; 4088usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_limit {
+pub flags: __u64,
+pub max_rfer: __u64,
+pub max_excl: __u64,
+pub rsv_rfer: __u64,
+pub rsv_excl: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_qgroup_inherit {
+pub flags: __u64,
+pub num_qgroups: __u64,
+pub num_ref_copies: __u64,
+pub num_excl_copies: __u64,
+pub lim: btrfs_qgroup_limit,
+pub qgroups: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_limit_args {
+pub qgroupid: __u64,
+pub lim: btrfs_qgroup_limit,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_vol_args_v2 {
+pub fd: __s64,
+pub transid: __u64,
+pub flags: __u64,
+pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1,
+pub __bindgen_anon_2: btrfs_ioctl_vol_args_v2__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1 {
+pub size: __u64,
+pub qgroup_inherit: *mut btrfs_qgroup_inherit,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_scrub_progress {
+pub data_extents_scrubbed: __u64,
+pub tree_extents_scrubbed: __u64,
+pub data_bytes_scrubbed: __u64,
+pub tree_bytes_scrubbed: __u64,
+pub read_errors: __u64,
+pub csum_errors: __u64,
+pub verify_errors: __u64,
+pub no_csum: __u64,
+pub csum_discards: __u64,
+pub super_errors: __u64,
+pub malloc_errors: __u64,
+pub uncorrectable_errors: __u64,
+pub corrected_errors: __u64,
+pub last_physical: __u64,
+pub unverified_errors: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_scrub_args {
+pub devid: __u64,
+pub start: __u64,
+pub end: __u64,
+pub flags: __u64,
+pub progress: btrfs_scrub_progress,
+pub unused: [__u64; 109usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_start_params {
+pub srcdevid: __u64,
+pub cont_reading_from_srcdev_mode: __u64,
+pub srcdev_name: [__u8; 1025usize],
+pub tgtdev_name: [__u8; 1025usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_status_params {
+pub replace_state: __u64,
+pub progress_1000: __u64,
+pub time_started: __u64,
+pub time_stopped: __u64,
+pub num_write_errors: __u64,
+pub num_uncorrectable_read_errors: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_args {
+pub cmd: __u64,
+pub result: __u64,
+pub __bindgen_anon_1: btrfs_ioctl_dev_replace_args__bindgen_ty_1,
+pub spare: [__u64; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_info_args {
+pub devid: __u64,
+pub uuid: [__u8; 16usize],
+pub bytes_used: __u64,
+pub total_bytes: __u64,
+pub fsid: [__u8; 16usize],
+pub unused: [__u64; 377usize],
+pub path: [__u8; 1024usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_fs_info_args {
+pub max_id: __u64,
+pub num_devices: __u64,
+pub fsid: [__u8; 16usize],
+pub nodesize: __u32,
+pub sectorsize: __u32,
+pub clone_alignment: __u32,
+pub csum_type: __u16,
+pub csum_size: __u16,
+pub flags: __u64,
+pub generation: __u64,
+pub metadata_uuid: [__u8; 16usize],
+pub reserved: [__u8; 944usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_feature_flags {
+pub compat_flags: __u64,
+pub compat_ro_flags: __u64,
+pub incompat_flags: __u64,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_balance_args {
+pub profiles: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1,
+pub devid: __u64,
+pub pstart: __u64,
+pub pend: __u64,
+pub vstart: __u64,
+pub vend: __u64,
+pub target: __u64,
+pub flags: __u64,
+pub __bindgen_anon_2: btrfs_balance_args__bindgen_ty_2,
+pub stripes_min: __u32,
+pub stripes_max: __u32,
+pub unused: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_args__bindgen_ty_1__bindgen_ty_1 {
+pub usage_min: __u32,
+pub usage_max: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_args__bindgen_ty_2__bindgen_ty_1 {
+pub limit_min: __u32,
+pub limit_max: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_progress {
+pub expected: __u64,
+pub considered: __u64,
+pub completed: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_balance_args {
+pub flags: __u64,
+pub state: __u64,
+pub data: btrfs_balance_args,
+pub meta: btrfs_balance_args,
+pub sys: btrfs_balance_args,
+pub stat: btrfs_balance_progress,
+pub unused: [__u64; 72usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_lookup_args {
+pub treeid: __u64,
+pub objectid: __u64,
+pub name: [crate::ctypes::c_char; 4080usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_lookup_user_args {
+pub dirid: __u64,
+pub treeid: __u64,
+pub name: [crate::ctypes::c_char; 256usize],
+pub path: [crate::ctypes::c_char; 3824usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_key {
+pub tree_id: __u64,
+pub min_objectid: __u64,
+pub max_objectid: __u64,
+pub min_offset: __u64,
+pub max_offset: __u64,
+pub min_transid: __u64,
+pub max_transid: __u64,
+pub min_type: __u32,
+pub max_type: __u32,
+pub nr_items: __u32,
+pub unused: __u32,
+pub unused1: __u64,
+pub unused2: __u64,
+pub unused3: __u64,
+pub unused4: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_header {
+pub transid: __u64,
+pub objectid: __u64,
+pub offset: __u64,
+pub type_: __u32,
+pub len: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_args {
+pub key: btrfs_ioctl_search_key,
+pub buf: [crate::ctypes::c_char; 3992usize],
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_search_args_v2 {
+pub key: btrfs_ioctl_search_key,
+pub buf_size: __u64,
+pub buf: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_clone_range_args {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_defrag_range_args {
+pub start: __u64,
+pub len: __u64,
+pub flags: __u64,
+pub extent_thresh: __u32,
+pub __bindgen_anon_1: btrfs_ioctl_defrag_range_args__bindgen_ty_1,
+pub unused: [__u32; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_defrag_range_args__bindgen_ty_1__bindgen_ty_1 {
+pub type_: __u8,
+pub level: __s8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_same_extent_info {
+pub fd: __s64,
+pub logical_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_same_args {
+pub logical_offset: __u64,
+pub length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<btrfs_ioctl_same_extent_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_space_info {
+pub flags: __u64,
+pub total_bytes: __u64,
+pub used_bytes: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_space_args {
+pub space_slots: __u64,
+pub total_spaces: __u64,
+pub spaces: __IncompleteArrayField<btrfs_ioctl_space_info>,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_data_container {
+pub bytes_left: __u32,
+pub bytes_missing: __u32,
+pub elem_cnt: __u32,
+pub elem_missed: __u32,
+pub val: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_path_args {
+pub inum: __u64,
+pub size: __u64,
+pub reserved: [__u64; 4usize],
+pub fspath: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_logical_ino_args {
+pub logical: __u64,
+pub size: __u64,
+pub reserved: [__u64; 3usize],
+pub flags: __u64,
+pub inodes: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_dev_stats {
+pub devid: __u64,
+pub nr_items: __u64,
+pub flags: __u64,
+pub values: [__u64; 5usize],
+pub unused: [__u64; 121usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_quota_ctl_args {
+pub cmd: __u64,
+pub status: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_quota_rescan_args {
+pub flags: __u64,
+pub progress: __u64,
+pub reserved: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_assign_args {
+pub assign: __u64,
+pub src: __u64,
+pub dst: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_create_args {
+pub create: __u64,
+pub qgroupid: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_timespec {
+pub sec: __u64,
+pub nsec: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_received_subvol_args {
+pub uuid: [crate::ctypes::c_char; 16usize],
+pub stransid: __u64,
+pub rtransid: __u64,
+pub stime: btrfs_ioctl_timespec,
+pub rtime: btrfs_ioctl_timespec,
+pub flags: __u64,
+pub reserved: [__u64; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_send_args {
+pub send_fd: __s64,
+pub clone_sources_count: __u64,
+pub clone_sources: *mut __u64,
+pub parent_root: __u64,
+pub flags: __u64,
+pub version: __u32,
+pub reserved: [__u8; 28usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_info_args {
+pub treeid: __u64,
+pub name: [crate::ctypes::c_char; 256usize],
+pub parent_id: __u64,
+pub dirid: __u64,
+pub generation: __u64,
+pub flags: __u64,
+pub uuid: [__u8; 16usize],
+pub parent_uuid: [__u8; 16usize],
+pub received_uuid: [__u8; 16usize],
+pub ctransid: __u64,
+pub otransid: __u64,
+pub stransid: __u64,
+pub rtransid: __u64,
+pub ctime: btrfs_ioctl_timespec,
+pub otime: btrfs_ioctl_timespec,
+pub stime: btrfs_ioctl_timespec,
+pub rtime: btrfs_ioctl_timespec,
+pub reserved: [__u64; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_rootref_args {
+pub min_treeid: __u64,
+pub rootref: [btrfs_ioctl_get_subvol_rootref_args__bindgen_ty_1; 255usize],
+pub num_items: __u8,
+pub align: [__u8; 7usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_rootref_args__bindgen_ty_1 {
+pub treeid: __u64,
+pub dirid: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_encoded_io_args {
+pub iov: *const iovec,
+pub iovcnt: crate::ctypes::c_ulong,
+pub offset: __s64,
+pub flags: __u64,
+pub len: __u64,
+pub unencoded_len: __u64,
+pub unencoded_offset: __u64,
+pub compression: __u32,
+pub encryption: __u32,
+pub reserved: [__u8; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_subvol_wait {
+pub subvolid: __u64,
+pub mode: __u32,
+pub count: __u32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_key {
+pub objectid: __le64,
+pub type_: __u8,
+pub offset: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_key {
+pub objectid: __u64,
+pub type_: __u8,
+pub offset: __u64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_header {
+pub csum: [__u8; 32usize],
+pub fsid: [__u8; 16usize],
+pub bytenr: __le64,
+pub flags: __le64,
+pub chunk_tree_uuid: [__u8; 16usize],
+pub generation: __le64,
+pub owner: __le64,
+pub nritems: __le32,
+pub level: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_backup {
+pub tree_root: __le64,
+pub tree_root_gen: __le64,
+pub chunk_root: __le64,
+pub chunk_root_gen: __le64,
+pub extent_root: __le64,
+pub extent_root_gen: __le64,
+pub fs_root: __le64,
+pub fs_root_gen: __le64,
+pub dev_root: __le64,
+pub dev_root_gen: __le64,
+pub csum_root: __le64,
+pub csum_root_gen: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub num_devices: __le64,
+pub unused_64: [__le64; 4usize],
+pub tree_root_level: __u8,
+pub chunk_root_level: __u8,
+pub extent_root_level: __u8,
+pub fs_root_level: __u8,
+pub dev_root_level: __u8,
+pub csum_root_level: __u8,
+pub unused_8: [__u8; 10usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_item {
+pub key: btrfs_disk_key,
+pub offset: __le32,
+pub size: __le32,
+}
+#[repr(C, packed)]
+pub struct btrfs_leaf {
+pub header: btrfs_header,
+pub items: __IncompleteArrayField<btrfs_item>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_key_ptr {
+pub key: btrfs_disk_key,
+pub blockptr: __le64,
+pub generation: __le64,
+}
+#[repr(C, packed)]
+pub struct btrfs_node {
+pub header: btrfs_header,
+pub ptrs: __IncompleteArrayField<btrfs_key_ptr>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_item {
+pub devid: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub io_align: __le32,
+pub io_width: __le32,
+pub sector_size: __le32,
+pub type_: __le64,
+pub generation: __le64,
+pub start_offset: __le64,
+pub dev_group: __le32,
+pub seek_speed: __u8,
+pub bandwidth: __u8,
+pub uuid: [__u8; 16usize],
+pub fsid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_stripe {
+pub devid: __le64,
+pub offset: __le64,
+pub dev_uuid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_chunk {
+pub length: __le64,
+pub owner: __le64,
+pub stripe_len: __le64,
+pub type_: __le64,
+pub io_align: __le32,
+pub io_width: __le32,
+pub sector_size: __le32,
+pub num_stripes: __le16,
+pub sub_stripes: __le16,
+pub stripe: btrfs_stripe,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_super_block {
+pub csum: [__u8; 32usize],
+pub fsid: [__u8; 16usize],
+pub bytenr: __le64,
+pub flags: __le64,
+pub magic: __le64,
+pub generation: __le64,
+pub root: __le64,
+pub chunk_root: __le64,
+pub log_root: __le64,
+pub __unused_log_root_transid: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub root_dir_objectid: __le64,
+pub num_devices: __le64,
+pub sectorsize: __le32,
+pub nodesize: __le32,
+pub __unused_leafsize: __le32,
+pub stripesize: __le32,
+pub sys_chunk_array_size: __le32,
+pub chunk_root_generation: __le64,
+pub compat_flags: __le64,
+pub compat_ro_flags: __le64,
+pub incompat_flags: __le64,
+pub csum_type: __le16,
+pub root_level: __u8,
+pub chunk_root_level: __u8,
+pub log_root_level: __u8,
+pub dev_item: btrfs_dev_item,
+pub label: [crate::ctypes::c_char; 256usize],
+pub cache_generation: __le64,
+pub uuid_tree_generation: __le64,
+pub metadata_uuid: [__u8; 16usize],
+pub nr_global_roots: __u64,
+pub reserved: [__le64; 27usize],
+pub sys_chunk_array: [__u8; 2048usize],
+pub super_roots: [btrfs_root_backup; 4usize],
+pub padding: [__u8; 565usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_entry {
+pub offset: __le64,
+pub bytes: __le64,
+pub type_: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_header {
+pub location: btrfs_disk_key,
+pub generation: __le64,
+pub num_entries: __le64,
+pub num_bitmaps: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_raid_stride {
+pub devid: __le64,
+pub physical: __le64,
+}
+#[repr(C, packed)]
+pub struct btrfs_stripe_extent {
+pub __bindgen_anon_1: btrfs_stripe_extent__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_stripe_extent__bindgen_ty_1 {
+pub __empty_strides: btrfs_stripe_extent__bindgen_ty_1__bindgen_ty_1,
+pub strides: __IncompleteArrayField<btrfs_raid_stride>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_stripe_extent__bindgen_ty_1__bindgen_ty_1 {}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_item {
+pub refs: __le64,
+pub generation: __le64,
+pub flags: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_item_v0 {
+pub refs: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_tree_block_info {
+pub key: btrfs_disk_key,
+pub level: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_data_ref {
+pub root: __le64,
+pub objectid: __le64,
+pub offset: __le64,
+pub count: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_shared_data_ref {
+pub count: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_owner_ref {
+pub root_id: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_inline_ref {
+pub type_: __u8,
+pub offset: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_extent {
+pub chunk_tree: __le64,
+pub chunk_objectid: __le64,
+pub chunk_offset: __le64,
+pub length: __le64,
+pub chunk_tree_uuid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_inode_ref {
+pub index: __le64,
+pub name_len: __le16,
+}
+#[repr(C, packed)]
+pub struct btrfs_inode_extref {
+pub parent_objectid: __le64,
+pub index: __le64,
+pub name_len: __le16,
+pub name: __IncompleteArrayField<__u8>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_timespec {
+pub sec: __le64,
+pub nsec: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_inode_item {
+pub generation: __le64,
+pub transid: __le64,
+pub size: __le64,
+pub nbytes: __le64,
+pub block_group: __le64,
+pub nlink: __le32,
+pub uid: __le32,
+pub gid: __le32,
+pub mode: __le32,
+pub rdev: __le64,
+pub flags: __le64,
+pub sequence: __le64,
+pub reserved: [__le64; 4usize],
+pub atime: btrfs_timespec,
+pub ctime: btrfs_timespec,
+pub mtime: btrfs_timespec,
+pub otime: btrfs_timespec,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dir_log_item {
+pub end: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dir_item {
+pub location: btrfs_disk_key,
+pub transid: __le64,
+pub data_len: __le16,
+pub name_len: __le16,
+pub type_: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_item {
+pub inode: btrfs_inode_item,
+pub generation: __le64,
+pub root_dirid: __le64,
+pub bytenr: __le64,
+pub byte_limit: __le64,
+pub bytes_used: __le64,
+pub last_snapshot: __le64,
+pub flags: __le64,
+pub refs: __le32,
+pub drop_progress: btrfs_disk_key,
+pub drop_level: __u8,
+pub level: __u8,
+pub generation_v2: __le64,
+pub uuid: [__u8; 16usize],
+pub parent_uuid: [__u8; 16usize],
+pub received_uuid: [__u8; 16usize],
+pub ctransid: __le64,
+pub otransid: __le64,
+pub stransid: __le64,
+pub rtransid: __le64,
+pub ctime: btrfs_timespec,
+pub otime: btrfs_timespec,
+pub stime: btrfs_timespec,
+pub rtime: btrfs_timespec,
+pub reserved: [__le64; 8usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_ref {
+pub dirid: __le64,
+pub sequence: __le64,
+pub name_len: __le16,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_disk_balance_args {
+pub profiles: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1,
+pub devid: __le64,
+pub pstart: __le64,
+pub pend: __le64,
+pub vstart: __le64,
+pub vend: __le64,
+pub target: __le64,
+pub flags: __le64,
+pub __bindgen_anon_2: btrfs_disk_balance_args__bindgen_ty_2,
+pub stripes_min: __le32,
+pub stripes_max: __le32,
+pub unused: [__le64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1 {
+pub usage_min: __le32,
+pub usage_max: __le32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1 {
+pub limit_min: __le32,
+pub limit_max: __le32,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_balance_item {
+pub flags: __le64,
+pub data: btrfs_disk_balance_args,
+pub meta: btrfs_disk_balance_args,
+pub sys: btrfs_disk_balance_args,
+pub unused: [__le64; 4usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_file_extent_item {
+pub generation: __le64,
+pub ram_bytes: __le64,
+pub compression: __u8,
+pub encryption: __u8,
+pub other_encoding: __le16,
+pub type_: __u8,
+pub disk_bytenr: __le64,
+pub disk_num_bytes: __le64,
+pub offset: __le64,
+pub num_bytes: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_csum_item {
+pub csum: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_stats_item {
+pub values: [__le64; 5usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_replace_item {
+pub src_devid: __le64,
+pub cursor_left: __le64,
+pub cursor_right: __le64,
+pub cont_reading_from_srcdev_mode: __le64,
+pub replace_state: __le64,
+pub time_started: __le64,
+pub time_stopped: __le64,
+pub num_write_errors: __le64,
+pub num_uncorrectable_read_errors: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_block_group_item {
+pub used: __le64,
+pub chunk_objectid: __le64,
+pub flags: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_info {
+pub extent_count: __le32,
+pub flags: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_status_item {
+pub version: __le64,
+pub generation: __le64,
+pub flags: __le64,
+pub rescan: __le64,
+pub enable_gen: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_info_item {
+pub generation: __le64,
+pub rfer: __le64,
+pub rfer_cmpr: __le64,
+pub excl: __le64,
+pub excl_cmpr: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_limit_item {
+pub flags: __le64,
+pub max_rfer: __le64,
+pub max_excl: __le64,
+pub rsv_rfer: __le64,
+pub rsv_excl: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_verity_descriptor_item {
+pub size: __le64,
+pub reserved: [__le64; 2usize],
+pub encryption: __u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct iovec {
+pub _address: u8,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const _IOC_NRBITS: u32 = 8;
+pub const _IOC_TYPEBITS: u32 = 8;
+pub const _IOC_SIZEBITS: u32 = 14;
+pub const _IOC_DIRBITS: u32 = 2;
+pub const _IOC_NRMASK: u32 = 255;
+pub const _IOC_TYPEMASK: u32 = 255;
+pub const _IOC_SIZEMASK: u32 = 16383;
+pub const _IOC_DIRMASK: u32 = 3;
+pub const _IOC_NRSHIFT: u32 = 0;
+pub const _IOC_TYPESHIFT: u32 = 8;
+pub const _IOC_SIZESHIFT: u32 = 16;
+pub const _IOC_DIRSHIFT: u32 = 30;
+pub const _IOC_NONE: u32 = 0;
+pub const _IOC_WRITE: u32 = 1;
+pub const _IOC_READ: u32 = 2;
+pub const IOC_IN: u32 = 1073741824;
+pub const IOC_OUT: u32 = 2147483648;
+pub const IOC_INOUT: u32 = 3221225472;
+pub const IOCSIZE_MASK: u32 = 1073676288;
+pub const IOCSIZE_SHIFT: u32 = 16;
+pub const NR_OPEN: u32 = 1024;
+pub const NGROUPS_MAX: u32 = 65536;
+pub const ARG_MAX: u32 = 131072;
+pub const LINK_MAX: u32 = 127;
+pub const MAX_CANON: u32 = 255;
+pub const MAX_INPUT: u32 = 255;
+pub const NAME_MAX: u32 = 255;
+pub const PATH_MAX: u32 = 4096;
+pub const PIPE_BUF: u32 = 4096;
+pub const XATTR_NAME_MAX: u32 = 255;
+pub const XATTR_SIZE_MAX: u32 = 65536;
+pub const XATTR_LIST_MAX: u32 = 65536;
+pub const RTSIG_MAX: u32 = 32;
+pub const FSCRYPT_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FSCRYPT_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FSCRYPT_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FSCRYPT_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FSCRYPT_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FSCRYPT_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64: u32 = 8;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32: u32 = 16;
+pub const FSCRYPT_MODE_AES_256_XTS: u32 = 1;
+pub const FSCRYPT_MODE_AES_256_CTS: u32 = 4;
+pub const FSCRYPT_MODE_AES_128_CBC: u32 = 5;
+pub const FSCRYPT_MODE_AES_128_CTS: u32 = 6;
+pub const FSCRYPT_MODE_SM4_XTS: u32 = 7;
+pub const FSCRYPT_MODE_SM4_CTS: u32 = 8;
+pub const FSCRYPT_MODE_ADIANTUM: u32 = 9;
+pub const FSCRYPT_MODE_AES_256_HCTR2: u32 = 10;
+pub const FSCRYPT_POLICY_V1: u32 = 0;
+pub const FSCRYPT_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FSCRYPT_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FSCRYPT_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FSCRYPT_MAX_KEY_SIZE: u32 = 64;
+pub const FSCRYPT_POLICY_V2: u32 = 2;
+pub const FSCRYPT_KEY_IDENTIFIER_SIZE: u32 = 16;
+pub const FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: u32 = 1;
+pub const FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: u32 = 2;
+pub const FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSY: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERS: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_ABSENT: u32 = 1;
+pub const FSCRYPT_KEY_STATUS_PRESENT: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVED: u32 = 3;
+pub const FSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELF: u32 = 1;
+pub const FS_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FS_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FS_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FS_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FS_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FS_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FS_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FS_POLICY_FLAGS_VALID: u32 = 7;
+pub const FS_ENCRYPTION_MODE_INVALID: u32 = 0;
+pub const FS_ENCRYPTION_MODE_AES_256_XTS: u32 = 1;
+pub const FS_ENCRYPTION_MODE_AES_256_GCM: u32 = 2;
+pub const FS_ENCRYPTION_MODE_AES_256_CBC: u32 = 3;
+pub const FS_ENCRYPTION_MODE_AES_256_CTS: u32 = 4;
+pub const FS_ENCRYPTION_MODE_AES_128_CBC: u32 = 5;
+pub const FS_ENCRYPTION_MODE_AES_128_CTS: u32 = 6;
+pub const FS_ENCRYPTION_MODE_ADIANTUM: u32 = 9;
+pub const FS_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FS_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FS_MAX_KEY_SIZE: u32 = 64;
+pub const MS_RDONLY: u32 = 1;
+pub const MS_NOSUID: u32 = 2;
+pub const MS_NODEV: u32 = 4;
+pub const MS_NOEXEC: u32 = 8;
+pub const MS_SYNCHRONOUS: u32 = 16;
+pub const MS_REMOUNT: u32 = 32;
+pub const MS_MANDLOCK: u32 = 64;
+pub const MS_DIRSYNC: u32 = 128;
+pub const MS_NOSYMFOLLOW: u32 = 256;
+pub const MS_NOATIME: u32 = 1024;
+pub const MS_NODIRATIME: u32 = 2048;
+pub const MS_BIND: u32 = 4096;
+pub const MS_MOVE: u32 = 8192;
+pub const MS_REC: u32 = 16384;
+pub const MS_VERBOSE: u32 = 32768;
+pub const MS_SILENT: u32 = 32768;
+pub const MS_POSIXACL: u32 = 65536;
+pub const MS_UNBINDABLE: u32 = 131072;
+pub const MS_PRIVATE: u32 = 262144;
+pub const MS_SLAVE: u32 = 524288;
+pub const MS_SHARED: u32 = 1048576;
+pub const MS_RELATIME: u32 = 2097152;
+pub const MS_KERNMOUNT: u32 = 4194304;
+pub const MS_I_VERSION: u32 = 8388608;
+pub const MS_STRICTATIME: u32 = 16777216;
+pub const MS_LAZYTIME: u32 = 33554432;
+pub const MS_SUBMOUNT: u32 = 67108864;
+pub const MS_NOREMOTELOCK: u32 = 134217728;
+pub const MS_NOSEC: u32 = 268435456;
+pub const MS_BORN: u32 = 536870912;
+pub const MS_ACTIVE: u32 = 1073741824;
+pub const MS_NOUSER: u32 = 2147483648;
+pub const MS_RMT_MASK: u32 = 41943121;
+pub const MS_MGC_VAL: u32 = 3236757504;
+pub const MS_MGC_MSK: u32 = 4294901760;
+pub const OPEN_TREE_CLONE: u32 = 1;
+pub const MOVE_MOUNT_F_SYMLINKS: u32 = 1;
+pub const MOVE_MOUNT_F_AUTOMOUNTS: u32 = 2;
+pub const MOVE_MOUNT_F_EMPTY_PATH: u32 = 4;
+pub const MOVE_MOUNT_T_SYMLINKS: u32 = 16;
+pub const MOVE_MOUNT_T_AUTOMOUNTS: u32 = 32;
+pub const MOVE_MOUNT_T_EMPTY_PATH: u32 = 64;
+pub const MOVE_MOUNT_SET_GROUP: u32 = 256;
+pub const MOVE_MOUNT_BENEATH: u32 = 512;
+pub const MOVE_MOUNT__MASK: u32 = 887;
+pub const FSOPEN_CLOEXEC: u32 = 1;
+pub const FSPICK_CLOEXEC: u32 = 1;
+pub const FSPICK_SYMLINK_NOFOLLOW: u32 = 2;
+pub const FSPICK_NO_AUTOMOUNT: u32 = 4;
+pub const FSPICK_EMPTY_PATH: u32 = 8;
+pub const FSMOUNT_CLOEXEC: u32 = 1;
+pub const MOUNT_ATTR_RDONLY: u32 = 1;
+pub const MOUNT_ATTR_NOSUID: u32 = 2;
+pub const MOUNT_ATTR_NODEV: u32 = 4;
+pub const MOUNT_ATTR_NOEXEC: u32 = 8;
+pub const MOUNT_ATTR__ATIME: u32 = 112;
+pub const MOUNT_ATTR_RELATIME: u32 = 0;
+pub const MOUNT_ATTR_NOATIME: u32 = 16;
+pub const MOUNT_ATTR_STRICTATIME: u32 = 32;
+pub const MOUNT_ATTR_NODIRATIME: u32 = 128;
+pub const MOUNT_ATTR_IDMAP: u32 = 1048576;
+pub const MOUNT_ATTR_NOSYMFOLLOW: u32 = 2097152;
+pub const MOUNT_ATTR_SIZE_VER0: u32 = 32;
+pub const MNT_ID_REQ_SIZE_VER0: u32 = 24;
+pub const MNT_ID_REQ_SIZE_VER1: u32 = 32;
+pub const STATMOUNT_SB_BASIC: u32 = 1;
+pub const STATMOUNT_MNT_BASIC: u32 = 2;
+pub const STATMOUNT_PROPAGATE_FROM: u32 = 4;
+pub const STATMOUNT_MNT_ROOT: u32 = 8;
+pub const STATMOUNT_MNT_POINT: u32 = 16;
+pub const STATMOUNT_FS_TYPE: u32 = 32;
+pub const STATMOUNT_MNT_NS_ID: u32 = 64;
+pub const STATMOUNT_MNT_OPTS: u32 = 128;
+pub const STATMOUNT_FS_SUBTYPE: u32 = 256;
+pub const STATMOUNT_SB_SOURCE: u32 = 512;
+pub const STATMOUNT_OPT_ARRAY: u32 = 1024;
+pub const STATMOUNT_OPT_SEC_ARRAY: u32 = 2048;
+pub const STATMOUNT_SUPPORTED_MASK: u32 = 4096;
+pub const STATMOUNT_MNT_UIDMAP: u32 = 8192;
+pub const STATMOUNT_MNT_GIDMAP: u32 = 16384;
+pub const LSMT_ROOT: i32 = -1;
+pub const LISTMOUNT_REVERSE: u32 = 1;
+pub const INR_OPEN_CUR: u32 = 1024;
+pub const INR_OPEN_MAX: u32 = 4096;
+pub const BLOCK_SIZE_BITS: u32 = 10;
+pub const BLOCK_SIZE: u32 = 1024;
+pub const IO_INTEGRITY_CHK_GUARD: u32 = 1;
+pub const IO_INTEGRITY_CHK_REFTAG: u32 = 2;
+pub const IO_INTEGRITY_CHK_APPTAG: u32 = 4;
+pub const IO_INTEGRITY_VALID_FLAGS: u32 = 7;
+pub const SEEK_SET: u32 = 0;
+pub const SEEK_CUR: u32 = 1;
+pub const SEEK_END: u32 = 2;
+pub const SEEK_DATA: u32 = 3;
+pub const SEEK_HOLE: u32 = 4;
+pub const SEEK_MAX: u32 = 4;
+pub const RENAME_NOREPLACE: u32 = 1;
+pub const RENAME_EXCHANGE: u32 = 2;
+pub const RENAME_WHITEOUT: u32 = 4;
+pub const FILE_DEDUPE_RANGE_SAME: u32 = 0;
+pub const FILE_DEDUPE_RANGE_DIFFERS: u32 = 1;
+pub const NR_FILE: u32 = 8192;
+pub const FS_XFLAG_REALTIME: u32 = 1;
+pub const FS_XFLAG_PREALLOC: u32 = 2;
+pub const FS_XFLAG_IMMUTABLE: u32 = 8;
+pub const FS_XFLAG_APPEND: u32 = 16;
+pub const FS_XFLAG_SYNC: u32 = 32;
+pub const FS_XFLAG_NOATIME: u32 = 64;
+pub const FS_XFLAG_NODUMP: u32 = 128;
+pub const FS_XFLAG_RTINHERIT: u32 = 256;
+pub const FS_XFLAG_PROJINHERIT: u32 = 512;
+pub const FS_XFLAG_NOSYMLINKS: u32 = 1024;
+pub const FS_XFLAG_EXTSIZE: u32 = 2048;
+pub const FS_XFLAG_EXTSZINHERIT: u32 = 4096;
+pub const FS_XFLAG_NODEFRAG: u32 = 8192;
+pub const FS_XFLAG_FILESTREAM: u32 = 16384;
+pub const FS_XFLAG_DAX: u32 = 32768;
+pub const FS_XFLAG_COWEXTSIZE: u32 = 65536;
+pub const FS_XFLAG_HASATTR: u32 = 2147483648;
+pub const BMAP_IOCTL: u32 = 1;
+pub const FSLABEL_MAX: u32 = 256;
+pub const FS_SECRM_FL: u32 = 1;
+pub const FS_UNRM_FL: u32 = 2;
+pub const FS_COMPR_FL: u32 = 4;
+pub const FS_SYNC_FL: u32 = 8;
+pub const FS_IMMUTABLE_FL: u32 = 16;
+pub const FS_APPEND_FL: u32 = 32;
+pub const FS_NODUMP_FL: u32 = 64;
+pub const FS_NOATIME_FL: u32 = 128;
+pub const FS_DIRTY_FL: u32 = 256;
+pub const FS_COMPRBLK_FL: u32 = 512;
+pub const FS_NOCOMP_FL: u32 = 1024;
+pub const FS_ENCRYPT_FL: u32 = 2048;
+pub const FS_BTREE_FL: u32 = 4096;
+pub const FS_INDEX_FL: u32 = 4096;
+pub const FS_IMAGIC_FL: u32 = 8192;
+pub const FS_JOURNAL_DATA_FL: u32 = 16384;
+pub const FS_NOTAIL_FL: u32 = 32768;
+pub const FS_DIRSYNC_FL: u32 = 65536;
+pub const FS_TOPDIR_FL: u32 = 131072;
+pub const FS_HUGE_FILE_FL: u32 = 262144;
+pub const FS_EXTENT_FL: u32 = 524288;
+pub const FS_VERITY_FL: u32 = 1048576;
+pub const FS_EA_INODE_FL: u32 = 2097152;
+pub const FS_EOFBLOCKS_FL: u32 = 4194304;
+pub const FS_NOCOW_FL: u32 = 8388608;
+pub const FS_DAX_FL: u32 = 33554432;
+pub const FS_INLINE_DATA_FL: u32 = 268435456;
+pub const FS_PROJINHERIT_FL: u32 = 536870912;
+pub const FS_CASEFOLD_FL: u32 = 1073741824;
+pub const FS_RESERVED_FL: u32 = 2147483648;
+pub const FS_FL_USER_VISIBLE: u32 = 253951;
+pub const FS_FL_USER_MODIFIABLE: u32 = 229631;
+pub const SYNC_FILE_RANGE_WAIT_BEFORE: u32 = 1;
+pub const SYNC_FILE_RANGE_WRITE: u32 = 2;
+pub const SYNC_FILE_RANGE_WAIT_AFTER: u32 = 4;
+pub const SYNC_FILE_RANGE_WRITE_AND_WAIT: u32 = 7;
+pub const PROCFS_IOCTL_MAGIC: u8 = 102u8;
+pub const PAGE_IS_WPALLOWED: u32 = 1;
+pub const PAGE_IS_WRITTEN: u32 = 2;
+pub const PAGE_IS_FILE: u32 = 4;
+pub const PAGE_IS_PRESENT: u32 = 8;
+pub const PAGE_IS_SWAPPED: u32 = 16;
+pub const PAGE_IS_PFNZERO: u32 = 32;
+pub const PAGE_IS_HUGE: u32 = 64;
+pub const PAGE_IS_SOFT_DIRTY: u32 = 128;
+pub const PAGE_IS_GUARD: u32 = 256;
+pub const PM_SCAN_WP_MATCHING: u32 = 1;
+pub const PM_SCAN_CHECK_WPASYNC: u32 = 2;
+pub const BTRFS_IOCTL_MAGIC: u32 = 148;
+pub const BTRFS_VOL_NAME_MAX: u32 = 255;
+pub const BTRFS_LABEL_SIZE: u32 = 256;
+pub const BTRFS_PATH_NAME_MAX: u32 = 4087;
+pub const BTRFS_DEVICE_PATH_NAME_MAX: u32 = 1024;
+pub const BTRFS_SUBVOL_NAME_MAX: u32 = 4039;
+pub const BTRFS_SUBVOL_CREATE_ASYNC: u32 = 1;
+pub const BTRFS_SUBVOL_RDONLY: u32 = 2;
+pub const BTRFS_SUBVOL_QGROUP_INHERIT: u32 = 4;
+pub const BTRFS_DEVICE_SPEC_BY_ID: u32 = 8;
+pub const BTRFS_SUBVOL_SPEC_BY_ID: u32 = 16;
+pub const BTRFS_VOL_ARG_V2_FLAGS_SUPPORTED: u32 = 30;
+pub const BTRFS_FSID_SIZE: u32 = 16;
+pub const BTRFS_UUID_SIZE: u32 = 16;
+pub const BTRFS_UUID_UNPARSED_SIZE: u32 = 37;
+pub const BTRFS_QGROUP_LIMIT_MAX_RFER: u32 = 1;
+pub const BTRFS_QGROUP_LIMIT_MAX_EXCL: u32 = 2;
+pub const BTRFS_QGROUP_LIMIT_RSV_RFER: u32 = 4;
+pub const BTRFS_QGROUP_LIMIT_RSV_EXCL: u32 = 8;
+pub const BTRFS_QGROUP_LIMIT_RFER_CMPR: u32 = 16;
+pub const BTRFS_QGROUP_LIMIT_EXCL_CMPR: u32 = 32;
+pub const BTRFS_QGROUP_INHERIT_SET_LIMITS: u32 = 1;
+pub const BTRFS_QGROUP_INHERIT_FLAGS_SUPP: u32 = 1;
+pub const BTRFS_DEVICE_REMOVE_ARGS_MASK: u32 = 8;
+pub const BTRFS_SUBVOL_CREATE_ARGS_MASK: u32 = 6;
+pub const BTRFS_SUBVOL_DELETE_ARGS_MASK: u32 = 16;
+pub const BTRFS_SCRUB_READONLY: u32 = 1;
+pub const BTRFS_SCRUB_SUPPORTED_FLAGS: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED: u32 = 3;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED: u32 = 4;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_START: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS: u32 = 3;
+pub const BTRFS_FS_INFO_FLAG_CSUM_INFO: u32 = 1;
+pub const BTRFS_FS_INFO_FLAG_GENERATION: u32 = 2;
+pub const BTRFS_FS_INFO_FLAG_METADATA_UUID: u32 = 4;
+pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE: u32 = 1;
+pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID: u32 = 2;
+pub const BTRFS_FEATURE_COMPAT_RO_VERITY: u32 = 4;
+pub const BTRFS_FEATURE_COMPAT_RO_BLOCK_GROUP_TREE: u32 = 8;
+pub const BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF: u32 = 1;
+pub const BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL: u32 = 2;
+pub const BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS: u32 = 4;
+pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO: u32 = 8;
+pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD: u32 = 16;
+pub const BTRFS_FEATURE_INCOMPAT_BIG_METADATA: u32 = 32;
+pub const BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF: u32 = 64;
+pub const BTRFS_FEATURE_INCOMPAT_RAID56: u32 = 128;
+pub const BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA: u32 = 256;
+pub const BTRFS_FEATURE_INCOMPAT_NO_HOLES: u32 = 512;
+pub const BTRFS_FEATURE_INCOMPAT_METADATA_UUID: u32 = 1024;
+pub const BTRFS_FEATURE_INCOMPAT_RAID1C34: u32 = 2048;
+pub const BTRFS_FEATURE_INCOMPAT_ZONED: u32 = 4096;
+pub const BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2: u32 = 8192;
+pub const BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE: u32 = 16384;
+pub const BTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA: u32 = 65536;
+pub const BTRFS_BALANCE_CTL_PAUSE: u32 = 1;
+pub const BTRFS_BALANCE_CTL_CANCEL: u32 = 2;
+pub const BTRFS_BALANCE_DATA: u32 = 1;
+pub const BTRFS_BALANCE_SYSTEM: u32 = 2;
+pub const BTRFS_BALANCE_METADATA: u32 = 4;
+pub const BTRFS_BALANCE_TYPE_MASK: u32 = 7;
+pub const BTRFS_BALANCE_FORCE: u32 = 8;
+pub const BTRFS_BALANCE_RESUME: u32 = 16;
+pub const BTRFS_BALANCE_ARGS_PROFILES: u32 = 1;
+pub const BTRFS_BALANCE_ARGS_USAGE: u32 = 2;
+pub const BTRFS_BALANCE_ARGS_DEVID: u32 = 4;
+pub const BTRFS_BALANCE_ARGS_DRANGE: u32 = 8;
+pub const BTRFS_BALANCE_ARGS_VRANGE: u32 = 16;
+pub const BTRFS_BALANCE_ARGS_LIMIT: u32 = 32;
+pub const BTRFS_BALANCE_ARGS_LIMIT_RANGE: u32 = 64;
+pub const BTRFS_BALANCE_ARGS_STRIPES_RANGE: u32 = 128;
+pub const BTRFS_BALANCE_ARGS_USAGE_RANGE: u32 = 1024;
+pub const BTRFS_BALANCE_ARGS_MASK: u32 = 1279;
+pub const BTRFS_BALANCE_ARGS_CONVERT: u32 = 256;
+pub const BTRFS_BALANCE_ARGS_SOFT: u32 = 512;
+pub const BTRFS_BALANCE_STATE_RUNNING: u32 = 1;
+pub const BTRFS_BALANCE_STATE_PAUSE_REQ: u32 = 2;
+pub const BTRFS_BALANCE_STATE_CANCEL_REQ: u32 = 4;
+pub const BTRFS_INO_LOOKUP_PATH_MAX: u32 = 4080;
+pub const BTRFS_INO_LOOKUP_USER_PATH_MAX: u32 = 3824;
+pub const BTRFS_DEFRAG_RANGE_COMPRESS: u32 = 1;
+pub const BTRFS_DEFRAG_RANGE_START_IO: u32 = 2;
+pub const BTRFS_DEFRAG_RANGE_COMPRESS_LEVEL: u32 = 4;
+pub const BTRFS_DEFRAG_RANGE_FLAGS_SUPP: u32 = 7;
+pub const BTRFS_SAME_DATA_DIFFERS: u32 = 1;
+pub const BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET: u32 = 1;
+pub const BTRFS_DEV_STATS_RESET: u32 = 1;
+pub const BTRFS_QUOTA_CTL_ENABLE: u32 = 1;
+pub const BTRFS_QUOTA_CTL_DISABLE: u32 = 2;
+pub const BTRFS_QUOTA_CTL_RESCAN__NOTUSED: u32 = 3;
+pub const BTRFS_QUOTA_CTL_ENABLE_SIMPLE_QUOTA: u32 = 4;
+pub const BTRFS_SEND_FLAG_NO_FILE_DATA: u32 = 1;
+pub const BTRFS_SEND_FLAG_OMIT_STREAM_HEADER: u32 = 2;
+pub const BTRFS_SEND_FLAG_OMIT_END_CMD: u32 = 4;
+pub const BTRFS_SEND_FLAG_VERSION: u32 = 8;
+pub const BTRFS_SEND_FLAG_COMPRESSED: u32 = 16;
+pub const BTRFS_SEND_FLAG_MASK: u32 = 31;
+pub const BTRFS_MAX_ROOTREF_BUFFER_NUM: u32 = 255;
+pub const BTRFS_ENCODED_IO_COMPRESSION_NONE: u32 = 0;
+pub const BTRFS_ENCODED_IO_COMPRESSION_ZLIB: u32 = 1;
+pub const BTRFS_ENCODED_IO_COMPRESSION_ZSTD: u32 = 2;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_4K: u32 = 3;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_8K: u32 = 4;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_16K: u32 = 5;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_32K: u32 = 6;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_64K: u32 = 7;
+pub const BTRFS_ENCODED_IO_COMPRESSION_TYPES: u32 = 8;
+pub const BTRFS_ENCODED_IO_ENCRYPTION_NONE: u32 = 0;
+pub const BTRFS_ENCODED_IO_ENCRYPTION_TYPES: u32 = 1;
+pub const BTRFS_SUBVOL_SYNC_WAIT_FOR_ONE: u32 = 0;
+pub const BTRFS_SUBVOL_SYNC_WAIT_FOR_QUEUED: u32 = 1;
+pub const BTRFS_SUBVOL_SYNC_COUNT: u32 = 2;
+pub const BTRFS_SUBVOL_SYNC_PEEK_FIRST: u32 = 3;
+pub const BTRFS_SUBVOL_SYNC_PEEK_LAST: u32 = 4;
+pub const BTRFS_MAGIC: u64 = 5575266562640200287;
+pub const BTRFS_MAX_LEVEL: u32 = 8;
+pub const BTRFS_NAME_LEN: u32 = 255;
+pub const BTRFS_LINK_MAX: u32 = 65535;
+pub const BTRFS_ROOT_TREE_OBJECTID: u32 = 1;
+pub const BTRFS_EXTENT_TREE_OBJECTID: u32 = 2;
+pub const BTRFS_CHUNK_TREE_OBJECTID: u32 = 3;
+pub const BTRFS_DEV_TREE_OBJECTID: u32 = 4;
+pub const BTRFS_FS_TREE_OBJECTID: u32 = 5;
+pub const BTRFS_ROOT_TREE_DIR_OBJECTID: u32 = 6;
+pub const BTRFS_CSUM_TREE_OBJECTID: u32 = 7;
+pub const BTRFS_QUOTA_TREE_OBJECTID: u32 = 8;
+pub const BTRFS_UUID_TREE_OBJECTID: u32 = 9;
+pub const BTRFS_FREE_SPACE_TREE_OBJECTID: u32 = 10;
+pub const BTRFS_BLOCK_GROUP_TREE_OBJECTID: u32 = 11;
+pub const BTRFS_RAID_STRIPE_TREE_OBJECTID: u32 = 12;
+pub const BTRFS_DEV_STATS_OBJECTID: u32 = 0;
+pub const BTRFS_BALANCE_OBJECTID: i32 = -4;
+pub const BTRFS_ORPHAN_OBJECTID: i32 = -5;
+pub const BTRFS_TREE_LOG_OBJECTID: i32 = -6;
+pub const BTRFS_TREE_LOG_FIXUP_OBJECTID: i32 = -7;
+pub const BTRFS_TREE_RELOC_OBJECTID: i32 = -8;
+pub const BTRFS_DATA_RELOC_TREE_OBJECTID: i32 = -9;
+pub const BTRFS_EXTENT_CSUM_OBJECTID: i32 = -10;
+pub const BTRFS_FREE_SPACE_OBJECTID: i32 = -11;
+pub const BTRFS_FREE_INO_OBJECTID: i32 = -12;
+pub const BTRFS_MULTIPLE_OBJECTIDS: i32 = -255;
+pub const BTRFS_FIRST_FREE_OBJECTID: u32 = 256;
+pub const BTRFS_LAST_FREE_OBJECTID: i32 = -256;
+pub const BTRFS_FIRST_CHUNK_TREE_OBJECTID: u32 = 256;
+pub const BTRFS_DEV_ITEMS_OBJECTID: u32 = 1;
+pub const BTRFS_BTREE_INODE_OBJECTID: u32 = 1;
+pub const BTRFS_EMPTY_SUBVOL_DIR_OBJECTID: u32 = 2;
+pub const BTRFS_DEV_REPLACE_DEVID: u32 = 0;
+pub const BTRFS_INODE_ITEM_KEY: u32 = 1;
+pub const BTRFS_INODE_REF_KEY: u32 = 12;
+pub const BTRFS_INODE_EXTREF_KEY: u32 = 13;
+pub const BTRFS_XATTR_ITEM_KEY: u32 = 24;
+pub const BTRFS_VERITY_DESC_ITEM_KEY: u32 = 36;
+pub const BTRFS_VERITY_MERKLE_ITEM_KEY: u32 = 37;
+pub const BTRFS_ORPHAN_ITEM_KEY: u32 = 48;
+pub const BTRFS_DIR_LOG_ITEM_KEY: u32 = 60;
+pub const BTRFS_DIR_LOG_INDEX_KEY: u32 = 72;
+pub const BTRFS_DIR_ITEM_KEY: u32 = 84;
+pub const BTRFS_DIR_INDEX_KEY: u32 = 96;
+pub const BTRFS_EXTENT_DATA_KEY: u32 = 108;
+pub const BTRFS_EXTENT_CSUM_KEY: u32 = 128;
+pub const BTRFS_ROOT_ITEM_KEY: u32 = 132;
+pub const BTRFS_ROOT_BACKREF_KEY: u32 = 144;
+pub const BTRFS_ROOT_REF_KEY: u32 = 156;
+pub const BTRFS_EXTENT_ITEM_KEY: u32 = 168;
+pub const BTRFS_METADATA_ITEM_KEY: u32 = 169;
+pub const BTRFS_EXTENT_OWNER_REF_KEY: u32 = 172;
+pub const BTRFS_TREE_BLOCK_REF_KEY: u32 = 176;
+pub const BTRFS_EXTENT_DATA_REF_KEY: u32 = 178;
+pub const BTRFS_SHARED_BLOCK_REF_KEY: u32 = 182;
+pub const BTRFS_SHARED_DATA_REF_KEY: u32 = 184;
+pub const BTRFS_BLOCK_GROUP_ITEM_KEY: u32 = 192;
+pub const BTRFS_FREE_SPACE_INFO_KEY: u32 = 198;
+pub const BTRFS_FREE_SPACE_EXTENT_KEY: u32 = 199;
+pub const BTRFS_FREE_SPACE_BITMAP_KEY: u32 = 200;
+pub const BTRFS_DEV_EXTENT_KEY: u32 = 204;
+pub const BTRFS_DEV_ITEM_KEY: u32 = 216;
+pub const BTRFS_CHUNK_ITEM_KEY: u32 = 228;
+pub const BTRFS_RAID_STRIPE_KEY: u32 = 230;
+pub const BTRFS_QGROUP_STATUS_KEY: u32 = 240;
+pub const BTRFS_QGROUP_INFO_KEY: u32 = 242;
+pub const BTRFS_QGROUP_LIMIT_KEY: u32 = 244;
+pub const BTRFS_QGROUP_RELATION_KEY: u32 = 246;
+pub const BTRFS_BALANCE_ITEM_KEY: u32 = 248;
+pub const BTRFS_TEMPORARY_ITEM_KEY: u32 = 248;
+pub const BTRFS_DEV_STATS_KEY: u32 = 249;
+pub const BTRFS_PERSISTENT_ITEM_KEY: u32 = 249;
+pub const BTRFS_DEV_REPLACE_KEY: u32 = 250;
+pub const BTRFS_UUID_KEY_SUBVOL: u32 = 251;
+pub const BTRFS_UUID_KEY_RECEIVED_SUBVOL: u32 = 252;
+pub const BTRFS_STRING_ITEM_KEY: u32 = 253;
+pub const BTRFS_MAX_METADATA_BLOCKSIZE: u32 = 65536;
+pub const BTRFS_CSUM_SIZE: u32 = 32;
+pub const BTRFS_FT_UNKNOWN: u32 = 0;
+pub const BTRFS_FT_REG_FILE: u32 = 1;
+pub const BTRFS_FT_DIR: u32 = 2;
+pub const BTRFS_FT_CHRDEV: u32 = 3;
+pub const BTRFS_FT_BLKDEV: u32 = 4;
+pub const BTRFS_FT_FIFO: u32 = 5;
+pub const BTRFS_FT_SOCK: u32 = 6;
+pub const BTRFS_FT_SYMLINK: u32 = 7;
+pub const BTRFS_FT_XATTR: u32 = 8;
+pub const BTRFS_FT_MAX: u32 = 9;
+pub const BTRFS_FT_ENCRYPTED: u32 = 128;
+pub const BTRFS_INODE_NODATASUM: u32 = 1;
+pub const BTRFS_INODE_NODATACOW: u32 = 2;
+pub const BTRFS_INODE_READONLY: u32 = 4;
+pub const BTRFS_INODE_NOCOMPRESS: u32 = 8;
+pub const BTRFS_INODE_PREALLOC: u32 = 16;
+pub const BTRFS_INODE_SYNC: u32 = 32;
+pub const BTRFS_INODE_IMMUTABLE: u32 = 64;
+pub const BTRFS_INODE_APPEND: u32 = 128;
+pub const BTRFS_INODE_NODUMP: u32 = 256;
+pub const BTRFS_INODE_NOATIME: u32 = 512;
+pub const BTRFS_INODE_DIRSYNC: u32 = 1024;
+pub const BTRFS_INODE_COMPRESS: u32 = 2048;
+pub const BTRFS_INODE_ROOT_ITEM_INIT: u32 = 2147483648;
+pub const BTRFS_INODE_FLAG_MASK: u32 = 2147487743;
+pub const BTRFS_INODE_RO_VERITY: u32 = 1;
+pub const BTRFS_INODE_RO_FLAG_MASK: u32 = 1;
+pub const BTRFS_SYSTEM_CHUNK_ARRAY_SIZE: u32 = 2048;
+pub const BTRFS_NUM_BACKUP_ROOTS: u32 = 4;
+pub const BTRFS_FREE_SPACE_EXTENT: u32 = 1;
+pub const BTRFS_FREE_SPACE_BITMAP: u32 = 2;
+pub const BTRFS_HEADER_FLAG_WRITTEN: u32 = 1;
+pub const BTRFS_HEADER_FLAG_RELOC: u32 = 2;
+pub const BTRFS_SUPER_FLAG_ERROR: u32 = 4;
+pub const BTRFS_SUPER_FLAG_SEEDING: u64 = 4294967296;
+pub const BTRFS_SUPER_FLAG_METADUMP: u64 = 8589934592;
+pub const BTRFS_SUPER_FLAG_METADUMP_V2: u64 = 17179869184;
+pub const BTRFS_SUPER_FLAG_CHANGING_FSID: u64 = 34359738368;
+pub const BTRFS_SUPER_FLAG_CHANGING_FSID_V2: u64 = 68719476736;
+pub const BTRFS_SUPER_FLAG_CHANGING_BG_TREE: u64 = 274877906944;
+pub const BTRFS_SUPER_FLAG_CHANGING_DATA_CSUM: u64 = 549755813888;
+pub const BTRFS_SUPER_FLAG_CHANGING_META_CSUM: u64 = 1099511627776;
+pub const BTRFS_EXTENT_FLAG_DATA: u32 = 1;
+pub const BTRFS_EXTENT_FLAG_TREE_BLOCK: u32 = 2;
+pub const BTRFS_BLOCK_FLAG_FULL_BACKREF: u32 = 256;
+pub const BTRFS_BACKREF_REV_MAX: u32 = 256;
+pub const BTRFS_BACKREF_REV_SHIFT: u32 = 56;
+pub const BTRFS_OLD_BACKREF_REV: u32 = 0;
+pub const BTRFS_MIXED_BACKREF_REV: u32 = 1;
+pub const BTRFS_EXTENT_FLAG_SUPER: u64 = 281474976710656;
+pub const BTRFS_ROOT_SUBVOL_RDONLY: u32 = 1;
+pub const BTRFS_ROOT_SUBVOL_DEAD: u64 = 281474976710656;
+pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
+pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
+pub const BTRFS_BLOCK_GROUP_DATA: u32 = 1;
+pub const BTRFS_BLOCK_GROUP_SYSTEM: u32 = 2;
+pub const BTRFS_BLOCK_GROUP_METADATA: u32 = 4;
+pub const BTRFS_BLOCK_GROUP_RAID0: u32 = 8;
+pub const BTRFS_BLOCK_GROUP_RAID1: u32 = 16;
+pub const BTRFS_BLOCK_GROUP_DUP: u32 = 32;
+pub const BTRFS_BLOCK_GROUP_RAID10: u32 = 64;
+pub const BTRFS_BLOCK_GROUP_RAID5: u32 = 128;
+pub const BTRFS_BLOCK_GROUP_RAID6: u32 = 256;
+pub const BTRFS_BLOCK_GROUP_RAID1C3: u32 = 512;
+pub const BTRFS_BLOCK_GROUP_RAID1C4: u32 = 1024;
+pub const BTRFS_BLOCK_GROUP_TYPE_MASK: u32 = 7;
+pub const BTRFS_BLOCK_GROUP_PROFILE_MASK: u32 = 2040;
+pub const BTRFS_BLOCK_GROUP_RAID56_MASK: u32 = 384;
+pub const BTRFS_BLOCK_GROUP_RAID1_MASK: u32 = 1552;
+pub const BTRFS_AVAIL_ALLOC_BIT_SINGLE: u64 = 281474976710656;
+pub const BTRFS_SPACE_INFO_GLOBAL_RSV: u64 = 562949953421312;
+pub const BTRFS_EXTENDED_PROFILE_MASK: u64 = 281474976712696;
+pub const BTRFS_FREE_SPACE_USING_BITMAPS: u32 = 1;
+pub const BTRFS_QGROUP_LEVEL_SHIFT: u32 = 48;
+pub const BTRFS_QGROUP_STATUS_FLAG_ON: u32 = 1;
+pub const BTRFS_QGROUP_STATUS_FLAG_RESCAN: u32 = 2;
+pub const BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT: u32 = 4;
+pub const BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE: u32 = 8;
+pub const BTRFS_QGROUP_STATUS_FLAGS_MASK: u32 = 15;
+pub const BTRFS_QGROUP_STATUS_VERSION: u32 = 1;
+pub const BTRFS_FILE_EXTENT_INLINE: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_INLINE;
+pub const BTRFS_FILE_EXTENT_REG: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_REG;
+pub const BTRFS_FILE_EXTENT_PREALLOC: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_PREALLOC;
+pub const BTRFS_NR_FILE_EXTENT_TYPES: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_NR_FILE_EXTENT_TYPES;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum fsconfig_command {
+FSCONFIG_SET_FLAG = 0,
+FSCONFIG_SET_STRING = 1,
+FSCONFIG_SET_BINARY = 2,
+FSCONFIG_SET_PATH = 3,
+FSCONFIG_SET_PATH_EMPTY = 4,
+FSCONFIG_SET_FD = 5,
+FSCONFIG_CMD_CREATE = 6,
+FSCONFIG_CMD_RECONFIGURE = 7,
+FSCONFIG_CMD_CREATE_EXCL = 8,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum procmap_query_flags {
+PROCMAP_QUERY_VMA_READABLE = 1,
+PROCMAP_QUERY_VMA_WRITABLE = 2,
+PROCMAP_QUERY_VMA_EXECUTABLE = 4,
+PROCMAP_QUERY_VMA_SHARED = 8,
+PROCMAP_QUERY_COVERING_OR_NEXT_VMA = 16,
+PROCMAP_QUERY_FILE_BACKED_VMA = 32,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_dev_stat_values {
+BTRFS_DEV_STAT_WRITE_ERRS = 0,
+BTRFS_DEV_STAT_READ_ERRS = 1,
+BTRFS_DEV_STAT_FLUSH_ERRS = 2,
+BTRFS_DEV_STAT_CORRUPTION_ERRS = 3,
+BTRFS_DEV_STAT_GENERATION_ERRS = 4,
+BTRFS_DEV_STAT_VALUES_MAX = 5,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_err_code {
+BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET = 1,
+BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET = 2,
+BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET = 3,
+BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET = 4,
+BTRFS_ERROR_DEV_TGT_REPLACE = 5,
+BTRFS_ERROR_DEV_MISSING_NOT_FOUND = 6,
+BTRFS_ERROR_DEV_ONLY_WRITABLE = 7,
+BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS = 8,
+BTRFS_ERROR_DEV_RAID1C3_MIN_NOT_MET = 9,
+BTRFS_ERROR_DEV_RAID1C4_MIN_NOT_MET = 10,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_csum_type {
+BTRFS_CSUM_TYPE_CRC32 = 0,
+BTRFS_CSUM_TYPE_XXHASH = 1,
+BTRFS_CSUM_TYPE_SHA256 = 2,
+BTRFS_CSUM_TYPE_BLAKE2 = 3,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+BTRFS_FILE_EXTENT_INLINE = 0,
+BTRFS_FILE_EXTENT_REG = 1,
+BTRFS_FILE_EXTENT_PREALLOC = 2,
+BTRFS_NR_FILE_EXTENT_TYPES = 3,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_get_policy_ex_arg__bindgen_ty_1 {
+pub version: __u8,
+pub v1: fscrypt_policy_v1,
+pub v2: fscrypt_policy_v2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_key_specifier__bindgen_ty_1 {
+pub __reserved: [__u8; 32usize],
+pub descriptor: [__u8; 8usize],
+pub identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_vol_args_v2__bindgen_ty_1 {
+pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1,
+pub unused: [__u64; 4usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_vol_args_v2__bindgen_ty_2 {
+pub name: [crate::ctypes::c_char; 4040usize],
+pub devid: __u64,
+pub subvolid: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_dev_replace_args__bindgen_ty_1 {
+pub start: btrfs_ioctl_dev_replace_start_params,
+pub status: btrfs_ioctl_dev_replace_status_params,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_balance_args__bindgen_ty_1 {
+pub usage: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_balance_args__bindgen_ty_2 {
+pub limit: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_defrag_range_args__bindgen_ty_1 {
+pub compress_type: __u32,
+pub compress: btrfs_ioctl_defrag_range_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_disk_balance_args__bindgen_ty_1 {
+pub usage: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_disk_balance_args__bindgen_ty_2 {
+pub limit: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1,
+}
+impl<T> __IncompleteArrayField<T> {
+#[inline]
+pub const fn new() -> Self {
+__IncompleteArrayField(::core::marker::PhantomData, [])
+}
+#[inline]
+pub fn as_ptr(&self) -> *const T {
+self as *const _ as *const T
+}
+#[inline]
+pub fn as_mut_ptr(&mut self) -> *mut T {
+self as *mut _ as *mut T
+}
+#[inline]
+pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+::core::slice::from_raw_parts(self.as_ptr(), len)
+}
+#[inline]
+pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+}
+}
+impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__IncompleteArrayField")
+}
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/elf_uapi.rs

@@ -0,0 +1,652 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type Elf32_Addr = __u32;
+pub type Elf32_Half = __u16;
+pub type Elf32_Off = __u32;
+pub type Elf32_Sword = __s32;
+pub type Elf32_Word = __u32;
+pub type Elf32_Versym = __u16;
+pub type Elf64_Addr = __u64;
+pub type Elf64_Half = __u16;
+pub type Elf64_SHalf = __s16;
+pub type Elf64_Off = __u64;
+pub type Elf64_Sword = __s32;
+pub type Elf64_Word = __u32;
+pub type Elf64_Xword = __u64;
+pub type Elf64_Sxword = __s64;
+pub type Elf64_Versym = __u16;
+pub type Elf32_Rel = elf32_rel;
+pub type Elf64_Rel = elf64_rel;
+pub type Elf32_Rela = elf32_rela;
+pub type Elf64_Rela = elf64_rela;
+pub type Elf32_Sym = elf32_sym;
+pub type Elf64_Sym = elf64_sym;
+pub type Elf32_Ehdr = elf32_hdr;
+pub type Elf64_Ehdr = elf64_hdr;
+pub type Elf32_Phdr = elf32_phdr;
+pub type Elf64_Phdr = elf64_phdr;
+pub type Elf32_Shdr = elf32_shdr;
+pub type Elf64_Shdr = elf64_shdr;
+pub type Elf32_Nhdr = elf32_note;
+pub type Elf64_Nhdr = elf64_note;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Elf32_Dyn {
+pub d_tag: Elf32_Sword,
+pub d_un: Elf32_Dyn__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Elf64_Dyn {
+pub d_tag: Elf64_Sxword,
+pub d_un: Elf64_Dyn__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_rel {
+pub r_offset: Elf32_Addr,
+pub r_info: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_rel {
+pub r_offset: Elf64_Addr,
+pub r_info: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_rela {
+pub r_offset: Elf32_Addr,
+pub r_info: Elf32_Word,
+pub r_addend: Elf32_Sword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_rela {
+pub r_offset: Elf64_Addr,
+pub r_info: Elf64_Xword,
+pub r_addend: Elf64_Sxword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_sym {
+pub st_name: Elf32_Word,
+pub st_value: Elf32_Addr,
+pub st_size: Elf32_Word,
+pub st_info: crate::ctypes::c_uchar,
+pub st_other: crate::ctypes::c_uchar,
+pub st_shndx: Elf32_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_sym {
+pub st_name: Elf64_Word,
+pub st_info: crate::ctypes::c_uchar,
+pub st_other: crate::ctypes::c_uchar,
+pub st_shndx: Elf64_Half,
+pub st_value: Elf64_Addr,
+pub st_size: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_hdr {
+pub e_ident: [crate::ctypes::c_uchar; 16usize],
+pub e_type: Elf32_Half,
+pub e_machine: Elf32_Half,
+pub e_version: Elf32_Word,
+pub e_entry: Elf32_Addr,
+pub e_phoff: Elf32_Off,
+pub e_shoff: Elf32_Off,
+pub e_flags: Elf32_Word,
+pub e_ehsize: Elf32_Half,
+pub e_phentsize: Elf32_Half,
+pub e_phnum: Elf32_Half,
+pub e_shentsize: Elf32_Half,
+pub e_shnum: Elf32_Half,
+pub e_shstrndx: Elf32_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_hdr {
+pub e_ident: [crate::ctypes::c_uchar; 16usize],
+pub e_type: Elf64_Half,
+pub e_machine: Elf64_Half,
+pub e_version: Elf64_Word,
+pub e_entry: Elf64_Addr,
+pub e_phoff: Elf64_Off,
+pub e_shoff: Elf64_Off,
+pub e_flags: Elf64_Word,
+pub e_ehsize: Elf64_Half,
+pub e_phentsize: Elf64_Half,
+pub e_phnum: Elf64_Half,
+pub e_shentsize: Elf64_Half,
+pub e_shnum: Elf64_Half,
+pub e_shstrndx: Elf64_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_phdr {
+pub p_type: Elf32_Word,
+pub p_offset: Elf32_Off,
+pub p_vaddr: Elf32_Addr,
+pub p_paddr: Elf32_Addr,
+pub p_filesz: Elf32_Word,
+pub p_memsz: Elf32_Word,
+pub p_flags: Elf32_Word,
+pub p_align: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_phdr {
+pub p_type: Elf64_Word,
+pub p_flags: Elf64_Word,
+pub p_offset: Elf64_Off,
+pub p_vaddr: Elf64_Addr,
+pub p_paddr: Elf64_Addr,
+pub p_filesz: Elf64_Xword,
+pub p_memsz: Elf64_Xword,
+pub p_align: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_shdr {
+pub sh_name: Elf32_Word,
+pub sh_type: Elf32_Word,
+pub sh_flags: Elf32_Word,
+pub sh_addr: Elf32_Addr,
+pub sh_offset: Elf32_Off,
+pub sh_size: Elf32_Word,
+pub sh_link: Elf32_Word,
+pub sh_info: Elf32_Word,
+pub sh_addralign: Elf32_Word,
+pub sh_entsize: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_shdr {
+pub sh_name: Elf64_Word,
+pub sh_type: Elf64_Word,
+pub sh_flags: Elf64_Xword,
+pub sh_addr: Elf64_Addr,
+pub sh_offset: Elf64_Off,
+pub sh_size: Elf64_Xword,
+pub sh_link: Elf64_Word,
+pub sh_info: Elf64_Word,
+pub sh_addralign: Elf64_Xword,
+pub sh_entsize: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_note {
+pub n_namesz: Elf32_Word,
+pub n_descsz: Elf32_Word,
+pub n_type: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_note {
+pub n_namesz: Elf64_Word,
+pub n_descsz: Elf64_Word,
+pub n_type: Elf64_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf32_Verdef {
+pub vd_version: Elf32_Half,
+pub vd_flags: Elf32_Half,
+pub vd_ndx: Elf32_Half,
+pub vd_cnt: Elf32_Half,
+pub vd_hash: Elf32_Word,
+pub vd_aux: Elf32_Word,
+pub vd_next: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf64_Verdef {
+pub vd_version: Elf64_Half,
+pub vd_flags: Elf64_Half,
+pub vd_ndx: Elf64_Half,
+pub vd_cnt: Elf64_Half,
+pub vd_hash: Elf64_Word,
+pub vd_aux: Elf64_Word,
+pub vd_next: Elf64_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf32_Verdaux {
+pub vda_name: Elf32_Word,
+pub vda_next: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf64_Verdaux {
+pub vda_name: Elf64_Word,
+pub vda_next: Elf64_Word,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const EM_NONE: u32 = 0;
+pub const EM_M32: u32 = 1;
+pub const EM_SPARC: u32 = 2;
+pub const EM_386: u32 = 3;
+pub const EM_68K: u32 = 4;
+pub const EM_88K: u32 = 5;
+pub const EM_486: u32 = 6;
+pub const EM_860: u32 = 7;
+pub const EM_MIPS: u32 = 8;
+pub const EM_MIPS_RS3_LE: u32 = 10;
+pub const EM_MIPS_RS4_BE: u32 = 10;
+pub const EM_PARISC: u32 = 15;
+pub const EM_SPARC32PLUS: u32 = 18;
+pub const EM_PPC: u32 = 20;
+pub const EM_PPC64: u32 = 21;
+pub const EM_SPU: u32 = 23;
+pub const EM_ARM: u32 = 40;
+pub const EM_SH: u32 = 42;
+pub const EM_SPARCV9: u32 = 43;
+pub const EM_H8_300: u32 = 46;
+pub const EM_IA_64: u32 = 50;
+pub const EM_X86_64: u32 = 62;
+pub const EM_S390: u32 = 22;
+pub const EM_CRIS: u32 = 76;
+pub const EM_M32R: u32 = 88;
+pub const EM_MN10300: u32 = 89;
+pub const EM_OPENRISC: u32 = 92;
+pub const EM_ARCOMPACT: u32 = 93;
+pub const EM_XTENSA: u32 = 94;
+pub const EM_BLACKFIN: u32 = 106;
+pub const EM_UNICORE: u32 = 110;
+pub const EM_ALTERA_NIOS2: u32 = 113;
+pub const EM_TI_C6000: u32 = 140;
+pub const EM_HEXAGON: u32 = 164;
+pub const EM_NDS32: u32 = 167;
+pub const EM_AARCH64: u32 = 183;
+pub const EM_TILEPRO: u32 = 188;
+pub const EM_MICROBLAZE: u32 = 189;
+pub const EM_TILEGX: u32 = 191;
+pub const EM_ARCV2: u32 = 195;
+pub const EM_RISCV: u32 = 243;
+pub const EM_BPF: u32 = 247;
+pub const EM_CSKY: u32 = 252;
+pub const EM_LOONGARCH: u32 = 258;
+pub const EM_FRV: u32 = 21569;
+pub const EM_ALPHA: u32 = 36902;
+pub const EM_CYGNUS_M32R: u32 = 36929;
+pub const EM_S390_OLD: u32 = 41872;
+pub const EM_CYGNUS_MN10300: u32 = 48879;
+pub const PT_NULL: u32 = 0;
+pub const PT_LOAD: u32 = 1;
+pub const PT_DYNAMIC: u32 = 2;
+pub const PT_INTERP: u32 = 3;
+pub const PT_NOTE: u32 = 4;
+pub const PT_SHLIB: u32 = 5;
+pub const PT_PHDR: u32 = 6;
+pub const PT_TLS: u32 = 7;
+pub const PT_LOOS: u32 = 1610612736;
+pub const PT_HIOS: u32 = 1879048191;
+pub const PT_LOPROC: u32 = 1879048192;
+pub const PT_HIPROC: u32 = 2147483647;
+pub const PT_GNU_EH_FRAME: u32 = 1685382480;
+pub const PT_GNU_STACK: u32 = 1685382481;
+pub const PT_GNU_RELRO: u32 = 1685382482;
+pub const PT_GNU_PROPERTY: u32 = 1685382483;
+pub const PT_AARCH64_MEMTAG_MTE: u32 = 1879048194;
+pub const PN_XNUM: u32 = 65535;
+pub const ET_NONE: u32 = 0;
+pub const ET_REL: u32 = 1;
+pub const ET_EXEC: u32 = 2;
+pub const ET_DYN: u32 = 3;
+pub const ET_CORE: u32 = 4;
+pub const ET_LOPROC: u32 = 65280;
+pub const ET_HIPROC: u32 = 65535;
+pub const DT_NULL: u32 = 0;
+pub const DT_NEEDED: u32 = 1;
+pub const DT_PLTRELSZ: u32 = 2;
+pub const DT_PLTGOT: u32 = 3;
+pub const DT_HASH: u32 = 4;
+pub const DT_STRTAB: u32 = 5;
+pub const DT_SYMTAB: u32 = 6;
+pub const DT_RELA: u32 = 7;
+pub const DT_RELASZ: u32 = 8;
+pub const DT_RELAENT: u32 = 9;
+pub const DT_STRSZ: u32 = 10;
+pub const DT_SYMENT: u32 = 11;
+pub const DT_INIT: u32 = 12;
+pub const DT_FINI: u32 = 13;
+pub const DT_SONAME: u32 = 14;
+pub const DT_RPATH: u32 = 15;
+pub const DT_SYMBOLIC: u32 = 16;
+pub const DT_REL: u32 = 17;
+pub const DT_RELSZ: u32 = 18;
+pub const DT_RELENT: u32 = 19;
+pub const DT_PLTREL: u32 = 20;
+pub const DT_DEBUG: u32 = 21;
+pub const DT_TEXTREL: u32 = 22;
+pub const DT_JMPREL: u32 = 23;
+pub const DT_ENCODING: u32 = 32;
+pub const OLD_DT_LOOS: u32 = 1610612736;
+pub const DT_LOOS: u32 = 1610612749;
+pub const DT_HIOS: u32 = 1879044096;
+pub const DT_VALRNGLO: u32 = 1879047424;
+pub const DT_VALRNGHI: u32 = 1879047679;
+pub const DT_ADDRRNGLO: u32 = 1879047680;
+pub const DT_GNU_HASH: u32 = 1879047925;
+pub const DT_ADDRRNGHI: u32 = 1879047935;
+pub const DT_VERSYM: u32 = 1879048176;
+pub const DT_RELACOUNT: u32 = 1879048185;
+pub const DT_RELCOUNT: u32 = 1879048186;
+pub const DT_FLAGS_1: u32 = 1879048187;
+pub const DT_VERDEF: u32 = 1879048188;
+pub const DT_VERDEFNUM: u32 = 1879048189;
+pub const DT_VERNEED: u32 = 1879048190;
+pub const DT_VERNEEDNUM: u32 = 1879048191;
+pub const OLD_DT_HIOS: u32 = 1879048191;
+pub const DT_LOPROC: u32 = 1879048192;
+pub const DT_HIPROC: u32 = 2147483647;
+pub const STB_LOCAL: u32 = 0;
+pub const STB_GLOBAL: u32 = 1;
+pub const STB_WEAK: u32 = 2;
+pub const STN_UNDEF: u32 = 0;
+pub const STT_NOTYPE: u32 = 0;
+pub const STT_OBJECT: u32 = 1;
+pub const STT_FUNC: u32 = 2;
+pub const STT_SECTION: u32 = 3;
+pub const STT_FILE: u32 = 4;
+pub const STT_COMMON: u32 = 5;
+pub const STT_TLS: u32 = 6;
+pub const VER_FLG_BASE: u32 = 1;
+pub const VER_FLG_WEAK: u32 = 2;
+pub const EI_NIDENT: u32 = 16;
+pub const PF_R: u32 = 4;
+pub const PF_W: u32 = 2;
+pub const PF_X: u32 = 1;
+pub const SHT_NULL: u32 = 0;
+pub const SHT_PROGBITS: u32 = 1;
+pub const SHT_SYMTAB: u32 = 2;
+pub const SHT_STRTAB: u32 = 3;
+pub const SHT_RELA: u32 = 4;
+pub const SHT_HASH: u32 = 5;
+pub const SHT_DYNAMIC: u32 = 6;
+pub const SHT_NOTE: u32 = 7;
+pub const SHT_NOBITS: u32 = 8;
+pub const SHT_REL: u32 = 9;
+pub const SHT_SHLIB: u32 = 10;
+pub const SHT_DYNSYM: u32 = 11;
+pub const SHT_NUM: u32 = 12;
+pub const SHT_LOPROC: u32 = 1879048192;
+pub const SHT_HIPROC: u32 = 2147483647;
+pub const SHT_LOUSER: u32 = 2147483648;
+pub const SHT_HIUSER: u32 = 4294967295;
+pub const SHF_WRITE: u32 = 1;
+pub const SHF_ALLOC: u32 = 2;
+pub const SHF_EXECINSTR: u32 = 4;
+pub const SHF_MERGE: u32 = 16;
+pub const SHF_STRINGS: u32 = 32;
+pub const SHF_INFO_LINK: u32 = 64;
+pub const SHF_LINK_ORDER: u32 = 128;
+pub const SHF_OS_NONCONFORMING: u32 = 256;
+pub const SHF_GROUP: u32 = 512;
+pub const SHF_TLS: u32 = 1024;
+pub const SHF_RELA_LIVEPATCH: u32 = 1048576;
+pub const SHF_RO_AFTER_INIT: u32 = 2097152;
+pub const SHF_ORDERED: u32 = 67108864;
+pub const SHF_EXCLUDE: u32 = 134217728;
+pub const SHF_MASKOS: u32 = 267386880;
+pub const SHF_MASKPROC: u32 = 4026531840;
+pub const SHN_UNDEF: u32 = 0;
+pub const SHN_LORESERVE: u32 = 65280;
+pub const SHN_LOPROC: u32 = 65280;
+pub const SHN_HIPROC: u32 = 65311;
+pub const SHN_LIVEPATCH: u32 = 65312;
+pub const SHN_ABS: u32 = 65521;
+pub const SHN_COMMON: u32 = 65522;
+pub const SHN_HIRESERVE: u32 = 65535;
+pub const EI_MAG0: u32 = 0;
+pub const EI_MAG1: u32 = 1;
+pub const EI_MAG2: u32 = 2;
+pub const EI_MAG3: u32 = 3;
+pub const EI_CLASS: u32 = 4;
+pub const EI_DATA: u32 = 5;
+pub const EI_VERSION: u32 = 6;
+pub const EI_OSABI: u32 = 7;
+pub const EI_PAD: u32 = 8;
+pub const ELFMAG0: u32 = 127;
+pub const ELFMAG1: u8 = 69u8;
+pub const ELFMAG2: u8 = 76u8;
+pub const ELFMAG3: u8 = 70u8;
+pub const ELFMAG: &[u8; 5] = b"\x7FELF\0";
+pub const SELFMAG: u32 = 4;
+pub const ELFCLASSNONE: u32 = 0;
+pub const ELFCLASS32: u32 = 1;
+pub const ELFCLASS64: u32 = 2;
+pub const ELFCLASSNUM: u32 = 3;
+pub const ELFDATANONE: u32 = 0;
+pub const ELFDATA2LSB: u32 = 1;
+pub const ELFDATA2MSB: u32 = 2;
+pub const EV_NONE: u32 = 0;
+pub const EV_CURRENT: u32 = 1;
+pub const EV_NUM: u32 = 2;
+pub const ELFOSABI_NONE: u32 = 0;
+pub const ELFOSABI_LINUX: u32 = 3;
+pub const ELF_OSABI: u32 = 0;
+pub const NN_GNU_PROPERTY_TYPE_0: &[u8; 4] = b"GNU\0";
+pub const NT_GNU_PROPERTY_TYPE_0: u32 = 5;
+pub const NN_PRSTATUS: &[u8; 5] = b"CORE\0";
+pub const NT_PRSTATUS: u32 = 1;
+pub const NN_PRFPREG: &[u8; 5] = b"CORE\0";
+pub const NT_PRFPREG: u32 = 2;
+pub const NN_PRPSINFO: &[u8; 5] = b"CORE\0";
+pub const NT_PRPSINFO: u32 = 3;
+pub const NN_TASKSTRUCT: &[u8; 5] = b"CORE\0";
+pub const NT_TASKSTRUCT: u32 = 4;
+pub const NN_AUXV: &[u8; 5] = b"CORE\0";
+pub const NT_AUXV: u32 = 6;
+pub const NN_SIGINFO: &[u8; 5] = b"CORE\0";
+pub const NT_SIGINFO: u32 = 1397311305;
+pub const NN_FILE: &[u8; 5] = b"CORE\0";
+pub const NT_FILE: u32 = 1179208773;
+pub const NN_PRXFPREG: &[u8; 6] = b"LINUX\0";
+pub const NT_PRXFPREG: u32 = 1189489535;
+pub const NN_PPC_VMX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_VMX: u32 = 256;
+pub const NN_PPC_SPE: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_SPE: u32 = 257;
+pub const NN_PPC_VSX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_VSX: u32 = 258;
+pub const NN_PPC_TAR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TAR: u32 = 259;
+pub const NN_PPC_PPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PPR: u32 = 260;
+pub const NN_PPC_DSCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_DSCR: u32 = 261;
+pub const NN_PPC_EBB: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_EBB: u32 = 262;
+pub const NN_PPC_PMU: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PMU: u32 = 263;
+pub const NN_PPC_TM_CGPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CGPR: u32 = 264;
+pub const NN_PPC_TM_CFPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CFPR: u32 = 265;
+pub const NN_PPC_TM_CVMX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CVMX: u32 = 266;
+pub const NN_PPC_TM_CVSX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CVSX: u32 = 267;
+pub const NN_PPC_TM_SPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_SPR: u32 = 268;
+pub const NN_PPC_TM_CTAR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CTAR: u32 = 269;
+pub const NN_PPC_TM_CPPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CPPR: u32 = 270;
+pub const NN_PPC_TM_CDSCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CDSCR: u32 = 271;
+pub const NN_PPC_PKEY: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PKEY: u32 = 272;
+pub const NN_PPC_DEXCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_DEXCR: u32 = 273;
+pub const NN_PPC_HASHKEYR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_HASHKEYR: u32 = 274;
+pub const NN_386_TLS: &[u8; 6] = b"LINUX\0";
+pub const NT_386_TLS: u32 = 512;
+pub const NN_386_IOPERM: &[u8; 6] = b"LINUX\0";
+pub const NT_386_IOPERM: u32 = 513;
+pub const NN_X86_XSTATE: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_XSTATE: u32 = 514;
+pub const NN_X86_SHSTK: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_SHSTK: u32 = 516;
+pub const NN_X86_XSAVE_LAYOUT: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_XSAVE_LAYOUT: u32 = 517;
+pub const NN_S390_HIGH_GPRS: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_HIGH_GPRS: u32 = 768;
+pub const NN_S390_TIMER: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TIMER: u32 = 769;
+pub const NN_S390_TODCMP: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TODCMP: u32 = 770;
+pub const NN_S390_TODPREG: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TODPREG: u32 = 771;
+pub const NN_S390_CTRS: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_CTRS: u32 = 772;
+pub const NN_S390_PREFIX: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_PREFIX: u32 = 773;
+pub const NN_S390_LAST_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_LAST_BREAK: u32 = 774;
+pub const NN_S390_SYSTEM_CALL: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_SYSTEM_CALL: u32 = 775;
+pub const NN_S390_TDB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TDB: u32 = 776;
+pub const NN_S390_VXRS_LOW: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_VXRS_LOW: u32 = 777;
+pub const NN_S390_VXRS_HIGH: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_VXRS_HIGH: u32 = 778;
+pub const NN_S390_GS_CB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_GS_CB: u32 = 779;
+pub const NN_S390_GS_BC: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_GS_BC: u32 = 780;
+pub const NN_S390_RI_CB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_RI_CB: u32 = 781;
+pub const NN_S390_PV_CPU_DATA: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_PV_CPU_DATA: u32 = 782;
+pub const NN_ARM_VFP: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_VFP: u32 = 1024;
+pub const NN_ARM_TLS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_TLS: u32 = 1025;
+pub const NN_ARM_HW_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_HW_BREAK: u32 = 1026;
+pub const NN_ARM_HW_WATCH: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_HW_WATCH: u32 = 1027;
+pub const NN_ARM_SYSTEM_CALL: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SYSTEM_CALL: u32 = 1028;
+pub const NN_ARM_SVE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SVE: u32 = 1029;
+pub const NN_ARM_PAC_MASK: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PAC_MASK: u32 = 1030;
+pub const NN_ARM_PACA_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PACA_KEYS: u32 = 1031;
+pub const NN_ARM_PACG_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PACG_KEYS: u32 = 1032;
+pub const NN_ARM_TAGGED_ADDR_CTRL: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_TAGGED_ADDR_CTRL: u32 = 1033;
+pub const NN_ARM_PAC_ENABLED_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PAC_ENABLED_KEYS: u32 = 1034;
+pub const NN_ARM_SSVE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SSVE: u32 = 1035;
+pub const NN_ARM_ZA: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_ZA: u32 = 1036;
+pub const NN_ARM_ZT: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_ZT: u32 = 1037;
+pub const NN_ARM_FPMR: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_FPMR: u32 = 1038;
+pub const NN_ARM_POE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_POE: u32 = 1039;
+pub const NN_ARM_GCS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_GCS: u32 = 1040;
+pub const NN_ARC_V2: &[u8; 6] = b"LINUX\0";
+pub const NT_ARC_V2: u32 = 1536;
+pub const NN_VMCOREDD: &[u8; 6] = b"LINUX\0";
+pub const NT_VMCOREDD: u32 = 1792;
+pub const NN_MIPS_DSP: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_DSP: u32 = 2048;
+pub const NN_MIPS_FP_MODE: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_FP_MODE: u32 = 2049;
+pub const NN_MIPS_MSA: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_MSA: u32 = 2050;
+pub const NN_RISCV_CSR: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_CSR: u32 = 2304;
+pub const NN_RISCV_VECTOR: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_VECTOR: u32 = 2305;
+pub const NN_RISCV_TAGGED_ADDR_CTRL: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_TAGGED_ADDR_CTRL: u32 = 2306;
+pub const NN_LOONGARCH_CPUCFG: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_CPUCFG: u32 = 2560;
+pub const NN_LOONGARCH_CSR: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_CSR: u32 = 2561;
+pub const NN_LOONGARCH_LSX: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LSX: u32 = 2562;
+pub const NN_LOONGARCH_LASX: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LASX: u32 = 2563;
+pub const NN_LOONGARCH_LBT: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LBT: u32 = 2564;
+pub const NN_LOONGARCH_HW_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_HW_BREAK: u32 = 2565;
+pub const NN_LOONGARCH_HW_WATCH: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_HW_WATCH: u32 = 2566;
+pub const GNU_PROPERTY_AARCH64_FEATURE_1_AND: u32 = 3221225472;
+pub const GNU_PROPERTY_AARCH64_FEATURE_1_BTI: u32 = 1;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Elf32_Dyn__bindgen_ty_1 {
+pub d_val: Elf32_Sword,
+pub d_ptr: Elf32_Addr,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Elf64_Dyn__bindgen_ty_1 {
+pub d_val: Elf64_Xword,
+pub d_ptr: Elf64_Addr,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/errno.rs

@@ -0,0 +1,135 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const EPERM: u32 = 1;
+pub const ENOENT: u32 = 2;
+pub const ESRCH: u32 = 3;
+pub const EINTR: u32 = 4;
+pub const EIO: u32 = 5;
+pub const ENXIO: u32 = 6;
+pub const E2BIG: u32 = 7;
+pub const ENOEXEC: u32 = 8;
+pub const EBADF: u32 = 9;
+pub const ECHILD: u32 = 10;
+pub const EAGAIN: u32 = 11;
+pub const ENOMEM: u32 = 12;
+pub const EACCES: u32 = 13;
+pub const EFAULT: u32 = 14;
+pub const ENOTBLK: u32 = 15;
+pub const EBUSY: u32 = 16;
+pub const EEXIST: u32 = 17;
+pub const EXDEV: u32 = 18;
+pub const ENODEV: u32 = 19;
+pub const ENOTDIR: u32 = 20;
+pub const EISDIR: u32 = 21;
+pub const EINVAL: u32 = 22;
+pub const ENFILE: u32 = 23;
+pub const EMFILE: u32 = 24;
+pub const ENOTTY: u32 = 25;
+pub const ETXTBSY: u32 = 26;
+pub const EFBIG: u32 = 27;
+pub const ENOSPC: u32 = 28;
+pub const ESPIPE: u32 = 29;
+pub const EROFS: u32 = 30;
+pub const EMLINK: u32 = 31;
+pub const EPIPE: u32 = 32;
+pub const EDOM: u32 = 33;
+pub const ERANGE: u32 = 34;
+pub const EDEADLK: u32 = 35;
+pub const ENAMETOOLONG: u32 = 36;
+pub const ENOLCK: u32 = 37;
+pub const ENOSYS: u32 = 38;
+pub const ENOTEMPTY: u32 = 39;
+pub const ELOOP: u32 = 40;
+pub const EWOULDBLOCK: u32 = 11;
+pub const ENOMSG: u32 = 42;
+pub const EIDRM: u32 = 43;
+pub const ECHRNG: u32 = 44;
+pub const EL2NSYNC: u32 = 45;
+pub const EL3HLT: u32 = 46;
+pub const EL3RST: u32 = 47;
+pub const ELNRNG: u32 = 48;
+pub const EUNATCH: u32 = 49;
+pub const ENOCSI: u32 = 50;
+pub const EL2HLT: u32 = 51;
+pub const EBADE: u32 = 52;
+pub const EBADR: u32 = 53;
+pub const EXFULL: u32 = 54;
+pub const ENOANO: u32 = 55;
+pub const EBADRQC: u32 = 56;
+pub const EBADSLT: u32 = 57;
+pub const EDEADLOCK: u32 = 35;
+pub const EBFONT: u32 = 59;
+pub const ENOSTR: u32 = 60;
+pub const ENODATA: u32 = 61;
+pub const ETIME: u32 = 62;
+pub const ENOSR: u32 = 63;
+pub const ENONET: u32 = 64;
+pub const ENOPKG: u32 = 65;
+pub const EREMOTE: u32 = 66;
+pub const ENOLINK: u32 = 67;
+pub const EADV: u32 = 68;
+pub const ESRMNT: u32 = 69;
+pub const ECOMM: u32 = 70;
+pub const EPROTO: u32 = 71;
+pub const EMULTIHOP: u32 = 72;
+pub const EDOTDOT: u32 = 73;
+pub const EBADMSG: u32 = 74;
+pub const EOVERFLOW: u32 = 75;
+pub const ENOTUNIQ: u32 = 76;
+pub const EBADFD: u32 = 77;
+pub const EREMCHG: u32 = 78;
+pub const ELIBACC: u32 = 79;
+pub const ELIBBAD: u32 = 80;
+pub const ELIBSCN: u32 = 81;
+pub const ELIBMAX: u32 = 82;
+pub const ELIBEXEC: u32 = 83;
+pub const EILSEQ: u32 = 84;
+pub const ERESTART: u32 = 85;
+pub const ESTRPIPE: u32 = 86;
+pub const EUSERS: u32 = 87;
+pub const ENOTSOCK: u32 = 88;
+pub const EDESTADDRREQ: u32 = 89;
+pub const EMSGSIZE: u32 = 90;
+pub const EPROTOTYPE: u32 = 91;
+pub const ENOPROTOOPT: u32 = 92;
+pub const EPROTONOSUPPORT: u32 = 93;
+pub const ESOCKTNOSUPPORT: u32 = 94;
+pub const EOPNOTSUPP: u32 = 95;
+pub const EPFNOSUPPORT: u32 = 96;
+pub const EAFNOSUPPORT: u32 = 97;
+pub const EADDRINUSE: u32 = 98;
+pub const EADDRNOTAVAIL: u32 = 99;
+pub const ENETDOWN: u32 = 100;
+pub const ENETUNREACH: u32 = 101;
+pub const ENETRESET: u32 = 102;
+pub const ECONNABORTED: u32 = 103;
+pub const ECONNRESET: u32 = 104;
+pub const ENOBUFS: u32 = 105;
+pub const EISCONN: u32 = 106;
+pub const ENOTCONN: u32 = 107;
+pub const ESHUTDOWN: u32 = 108;
+pub const ETOOMANYREFS: u32 = 109;
+pub const ETIMEDOUT: u32 = 110;
+pub const ECONNREFUSED: u32 = 111;
+pub const EHOSTDOWN: u32 = 112;
+pub const EHOSTUNREACH: u32 = 113;
+pub const EALREADY: u32 = 114;
+pub const EINPROGRESS: u32 = 115;
+pub const ESTALE: u32 = 116;
+pub const EUCLEAN: u32 = 117;
+pub const ENOTNAM: u32 = 118;
+pub const ENAVAIL: u32 = 119;
+pub const EISNAM: u32 = 120;
+pub const EREMOTEIO: u32 = 121;
+pub const EDQUOT: u32 = 122;
+pub const ENOMEDIUM: u32 = 123;
+pub const EMEDIUMTYPE: u32 = 124;
+pub const ECANCELED: u32 = 125;
+pub const ENOKEY: u32 = 126;
+pub const EKEYEXPIRED: u32 = 127;
+pub const EKEYREVOKED: u32 = 128;
+pub const EKEYREJECTED: u32 = 129;
+pub const EOWNERDEAD: u32 = 130;
+pub const ENOTRECOVERABLE: u32 = 131;
+pub const ERFKILL: u32 = 132;
+pub const EHWPOISON: u32 = 133;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/if_ether.rs

@@ -0,0 +1,168 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct ethhdr {
+pub h_dest: [crate::ctypes::c_uchar; 6usize],
+pub h_source: [crate::ctypes::c_uchar; 6usize],
+pub h_proto: __be16,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const ETH_ALEN: u32 = 6;
+pub const ETH_TLEN: u32 = 2;
+pub const ETH_HLEN: u32 = 14;
+pub const ETH_ZLEN: u32 = 60;
+pub const ETH_DATA_LEN: u32 = 1500;
+pub const ETH_FRAME_LEN: u32 = 1514;
+pub const ETH_FCS_LEN: u32 = 4;
+pub const ETH_MIN_MTU: u32 = 68;
+pub const ETH_MAX_MTU: u32 = 65535;
+pub const ETH_P_LOOP: u32 = 96;
+pub const ETH_P_PUP: u32 = 512;
+pub const ETH_P_PUPAT: u32 = 513;
+pub const ETH_P_TSN: u32 = 8944;
+pub const ETH_P_ERSPAN2: u32 = 8939;
+pub const ETH_P_IP: u32 = 2048;
+pub const ETH_P_X25: u32 = 2053;
+pub const ETH_P_ARP: u32 = 2054;
+pub const ETH_P_BPQ: u32 = 2303;
+pub const ETH_P_IEEEPUP: u32 = 2560;
+pub const ETH_P_IEEEPUPAT: u32 = 2561;
+pub const ETH_P_BATMAN: u32 = 17157;
+pub const ETH_P_DEC: u32 = 24576;
+pub const ETH_P_DNA_DL: u32 = 24577;
+pub const ETH_P_DNA_RC: u32 = 24578;
+pub const ETH_P_DNA_RT: u32 = 24579;
+pub const ETH_P_LAT: u32 = 24580;
+pub const ETH_P_DIAG: u32 = 24581;
+pub const ETH_P_CUST: u32 = 24582;
+pub const ETH_P_SCA: u32 = 24583;
+pub const ETH_P_TEB: u32 = 25944;
+pub const ETH_P_RARP: u32 = 32821;
+pub const ETH_P_ATALK: u32 = 32923;
+pub const ETH_P_AARP: u32 = 33011;
+pub const ETH_P_8021Q: u32 = 33024;
+pub const ETH_P_ERSPAN: u32 = 35006;
+pub const ETH_P_IPX: u32 = 33079;
+pub const ETH_P_IPV6: u32 = 34525;
+pub const ETH_P_PAUSE: u32 = 34824;
+pub const ETH_P_SLOW: u32 = 34825;
+pub const ETH_P_WCCP: u32 = 34878;
+pub const ETH_P_MPLS_UC: u32 = 34887;
+pub const ETH_P_MPLS_MC: u32 = 34888;
+pub const ETH_P_ATMMPOA: u32 = 34892;
+pub const ETH_P_PPP_DISC: u32 = 34915;
+pub const ETH_P_PPP_SES: u32 = 34916;
+pub const ETH_P_LINK_CTL: u32 = 34924;
+pub const ETH_P_ATMFATE: u32 = 34948;
+pub const ETH_P_PAE: u32 = 34958;
+pub const ETH_P_PROFINET: u32 = 34962;
+pub const ETH_P_REALTEK: u32 = 34969;
+pub const ETH_P_AOE: u32 = 34978;
+pub const ETH_P_ETHERCAT: u32 = 34980;
+pub const ETH_P_8021AD: u32 = 34984;
+pub const ETH_P_802_EX1: u32 = 34997;
+pub const ETH_P_PREAUTH: u32 = 35015;
+pub const ETH_P_TIPC: u32 = 35018;
+pub const ETH_P_LLDP: u32 = 35020;
+pub const ETH_P_MRP: u32 = 35043;
+pub const ETH_P_MACSEC: u32 = 35045;
+pub const ETH_P_8021AH: u32 = 35047;
+pub const ETH_P_MVRP: u32 = 35061;
+pub const ETH_P_1588: u32 = 35063;
+pub const ETH_P_NCSI: u32 = 35064;
+pub const ETH_P_PRP: u32 = 35067;
+pub const ETH_P_CFM: u32 = 35074;
+pub const ETH_P_FCOE: u32 = 35078;
+pub const ETH_P_IBOE: u32 = 35093;
+pub const ETH_P_TDLS: u32 = 35085;
+pub const ETH_P_FIP: u32 = 35092;
+pub const ETH_P_80221: u32 = 35095;
+pub const ETH_P_HSR: u32 = 35119;
+pub const ETH_P_NSH: u32 = 35151;
+pub const ETH_P_LOOPBACK: u32 = 36864;
+pub const ETH_P_QINQ1: u32 = 37120;
+pub const ETH_P_QINQ2: u32 = 37376;
+pub const ETH_P_QINQ3: u32 = 37632;
+pub const ETH_P_EDSA: u32 = 56026;
+pub const ETH_P_DSA_8021Q: u32 = 56027;
+pub const ETH_P_DSA_A5PSW: u32 = 57345;
+pub const ETH_P_IFE: u32 = 60734;
+pub const ETH_P_AF_IUCV: u32 = 64507;
+pub const ETH_P_802_3_MIN: u32 = 1536;
+pub const ETH_P_802_3: u32 = 1;
+pub const ETH_P_AX25: u32 = 2;
+pub const ETH_P_ALL: u32 = 3;
+pub const ETH_P_802_2: u32 = 4;
+pub const ETH_P_SNAP: u32 = 5;
+pub const ETH_P_DDCMP: u32 = 6;
+pub const ETH_P_WAN_PPP: u32 = 7;
+pub const ETH_P_PPP_MP: u32 = 8;
+pub const ETH_P_LOCALTALK: u32 = 9;
+pub const ETH_P_CAN: u32 = 12;
+pub const ETH_P_CANFD: u32 = 13;
+pub const ETH_P_CANXL: u32 = 14;
+pub const ETH_P_PPPTALK: u32 = 16;
+pub const ETH_P_TR_802_2: u32 = 17;
+pub const ETH_P_MOBITEX: u32 = 21;
+pub const ETH_P_CONTROL: u32 = 22;
+pub const ETH_P_IRDA: u32 = 23;
+pub const ETH_P_ECONET: u32 = 24;
+pub const ETH_P_HDLC: u32 = 25;
+pub const ETH_P_ARCNET: u32 = 26;
+pub const ETH_P_DSA: u32 = 27;
+pub const ETH_P_TRAILER: u32 = 28;
+pub const ETH_P_PHONET: u32 = 245;
+pub const ETH_P_IEEE802154: u32 = 246;
+pub const ETH_P_CAIF: u32 = 247;
+pub const ETH_P_XDSA: u32 = 248;
+pub const ETH_P_MAP: u32 = 249;
+pub const ETH_P_MCTP: u32 = 250;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/if_packet.rs

@@ -0,0 +1,311 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_pkt {
+pub spkt_family: crate::ctypes::c_ushort,
+pub spkt_device: [crate::ctypes::c_uchar; 14usize],
+pub spkt_protocol: __be16,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_ll {
+pub sll_family: crate::ctypes::c_ushort,
+pub sll_protocol: __be16,
+pub sll_ifindex: crate::ctypes::c_int,
+pub sll_hatype: crate::ctypes::c_ushort,
+pub sll_pkttype: crate::ctypes::c_uchar,
+pub sll_halen: crate::ctypes::c_uchar,
+pub sll_addr: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_stats {
+pub tp_packets: crate::ctypes::c_uint,
+pub tp_drops: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_stats_v3 {
+pub tp_packets: crate::ctypes::c_uint,
+pub tp_drops: crate::ctypes::c_uint,
+pub tp_freeze_q_cnt: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_rollover_stats {
+pub tp_all: __u64,
+pub tp_huge: __u64,
+pub tp_failed: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_auxdata {
+pub tp_status: __u32,
+pub tp_len: __u32,
+pub tp_snaplen: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub tp_vlan_tci: __u16,
+pub tp_vlan_tpid: __u16,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_hdr {
+pub tp_status: crate::ctypes::c_ulong,
+pub tp_len: crate::ctypes::c_uint,
+pub tp_snaplen: crate::ctypes::c_uint,
+pub tp_mac: crate::ctypes::c_ushort,
+pub tp_net: crate::ctypes::c_ushort,
+pub tp_sec: crate::ctypes::c_uint,
+pub tp_usec: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket2_hdr {
+pub tp_status: __u32,
+pub tp_len: __u32,
+pub tp_snaplen: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub tp_sec: __u32,
+pub tp_nsec: __u32,
+pub tp_vlan_tci: __u16,
+pub tp_vlan_tpid: __u16,
+pub tp_padding: [__u8; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_hdr_variant1 {
+pub tp_rxhash: __u32,
+pub tp_vlan_tci: __u32,
+pub tp_vlan_tpid: __u16,
+pub tp_padding: __u16,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket3_hdr {
+pub tp_next_offset: __u32,
+pub tp_sec: __u32,
+pub tp_nsec: __u32,
+pub tp_snaplen: __u32,
+pub tp_len: __u32,
+pub tp_status: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub __bindgen_anon_1: tpacket3_hdr__bindgen_ty_1,
+pub tp_padding: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket_bd_ts {
+pub ts_sec: crate::ctypes::c_uint,
+pub __bindgen_anon_1: tpacket_bd_ts__bindgen_ty_1,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Copy, Clone)]
+pub struct tpacket_hdr_v1 {
+pub block_status: __u32,
+pub num_pkts: __u32,
+pub offset_to_first_pkt: __u32,
+pub blk_len: __u32,
+pub seq_num: __u64,
+pub ts_first_pkt: tpacket_bd_ts,
+pub ts_last_pkt: tpacket_bd_ts,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket_block_desc {
+pub version: __u32,
+pub offset_to_priv: __u32,
+pub hdr: tpacket_bd_header_u,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_req {
+pub tp_block_size: crate::ctypes::c_uint,
+pub tp_block_nr: crate::ctypes::c_uint,
+pub tp_frame_size: crate::ctypes::c_uint,
+pub tp_frame_nr: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_req3 {
+pub tp_block_size: crate::ctypes::c_uint,
+pub tp_block_nr: crate::ctypes::c_uint,
+pub tp_frame_size: crate::ctypes::c_uint,
+pub tp_frame_nr: crate::ctypes::c_uint,
+pub tp_retire_blk_tov: crate::ctypes::c_uint,
+pub tp_sizeof_priv: crate::ctypes::c_uint,
+pub tp_feature_req_word: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct packet_mreq {
+pub mr_ifindex: crate::ctypes::c_int,
+pub mr_type: crate::ctypes::c_ushort,
+pub mr_alen: crate::ctypes::c_ushort,
+pub mr_address: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fanout_args {
+pub id: __u16,
+pub type_flags: __u16,
+pub max_num_members: __u32,
+}
+pub const __LITTLE_ENDIAN: u32 = 1234;
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const PACKET_HOST: u32 = 0;
+pub const PACKET_BROADCAST: u32 = 1;
+pub const PACKET_MULTICAST: u32 = 2;
+pub const PACKET_OTHERHOST: u32 = 3;
+pub const PACKET_OUTGOING: u32 = 4;
+pub const PACKET_LOOPBACK: u32 = 5;
+pub const PACKET_USER: u32 = 6;
+pub const PACKET_KERNEL: u32 = 7;
+pub const PACKET_FASTROUTE: u32 = 6;
+pub const PACKET_ADD_MEMBERSHIP: u32 = 1;
+pub const PACKET_DROP_MEMBERSHIP: u32 = 2;
+pub const PACKET_RECV_OUTPUT: u32 = 3;
+pub const PACKET_RX_RING: u32 = 5;
+pub const PACKET_STATISTICS: u32 = 6;
+pub const PACKET_COPY_THRESH: u32 = 7;
+pub const PACKET_AUXDATA: u32 = 8;
+pub const PACKET_ORIGDEV: u32 = 9;
+pub const PACKET_VERSION: u32 = 10;
+pub const PACKET_HDRLEN: u32 = 11;
+pub const PACKET_RESERVE: u32 = 12;
+pub const PACKET_TX_RING: u32 = 13;
+pub const PACKET_LOSS: u32 = 14;
+pub const PACKET_VNET_HDR: u32 = 15;
+pub const PACKET_TX_TIMESTAMP: u32 = 16;
+pub const PACKET_TIMESTAMP: u32 = 17;
+pub const PACKET_FANOUT: u32 = 18;
+pub const PACKET_TX_HAS_OFF: u32 = 19;
+pub const PACKET_QDISC_BYPASS: u32 = 20;
+pub const PACKET_ROLLOVER_STATS: u32 = 21;
+pub const PACKET_FANOUT_DATA: u32 = 22;
+pub const PACKET_IGNORE_OUTGOING: u32 = 23;
+pub const PACKET_VNET_HDR_SZ: u32 = 24;
+pub const PACKET_FANOUT_HASH: u32 = 0;
+pub const PACKET_FANOUT_LB: u32 = 1;
+pub const PACKET_FANOUT_CPU: u32 = 2;
+pub const PACKET_FANOUT_ROLLOVER: u32 = 3;
+pub const PACKET_FANOUT_RND: u32 = 4;
+pub const PACKET_FANOUT_QM: u32 = 5;
+pub const PACKET_FANOUT_CBPF: u32 = 6;
+pub const PACKET_FANOUT_EBPF: u32 = 7;
+pub const PACKET_FANOUT_FLAG_ROLLOVER: u32 = 4096;
+pub const PACKET_FANOUT_FLAG_UNIQUEID: u32 = 8192;
+pub const PACKET_FANOUT_FLAG_IGNORE_OUTGOING: u32 = 16384;
+pub const PACKET_FANOUT_FLAG_DEFRAG: u32 = 32768;
+pub const TP_STATUS_KERNEL: u32 = 0;
+pub const TP_STATUS_USER: u32 = 1;
+pub const TP_STATUS_COPY: u32 = 2;
+pub const TP_STATUS_LOSING: u32 = 4;
+pub const TP_STATUS_CSUMNOTREADY: u32 = 8;
+pub const TP_STATUS_VLAN_VALID: u32 = 16;
+pub const TP_STATUS_BLK_TMO: u32 = 32;
+pub const TP_STATUS_VLAN_TPID_VALID: u32 = 64;
+pub const TP_STATUS_CSUM_VALID: u32 = 128;
+pub const TP_STATUS_GSO_TCP: u32 = 256;
+pub const TP_STATUS_AVAILABLE: u32 = 0;
+pub const TP_STATUS_SEND_REQUEST: u32 = 1;
+pub const TP_STATUS_SENDING: u32 = 2;
+pub const TP_STATUS_WRONG_FORMAT: u32 = 4;
+pub const TP_STATUS_TS_SOFTWARE: u32 = 536870912;
+pub const TP_STATUS_TS_SYS_HARDWARE: u32 = 1073741824;
+pub const TP_STATUS_TS_RAW_HARDWARE: u32 = 2147483648;
+pub const TP_FT_REQ_FILL_RXHASH: u32 = 1;
+pub const TPACKET_ALIGNMENT: u32 = 16;
+pub const PACKET_MR_MULTICAST: u32 = 0;
+pub const PACKET_MR_PROMISC: u32 = 1;
+pub const PACKET_MR_ALLMULTI: u32 = 2;
+pub const PACKET_MR_UNICAST: u32 = 3;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum tpacket_versions {
+TPACKET_V1 = 0,
+TPACKET_V2 = 1,
+TPACKET_V3 = 2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_stats_u {
+pub stats1: tpacket_stats,
+pub stats3: tpacket_stats_v3,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket3_hdr__bindgen_ty_1 {
+pub hv1: tpacket_hdr_variant1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_bd_ts__bindgen_ty_1 {
+pub ts_usec: crate::ctypes::c_uint,
+pub ts_nsec: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_bd_header_u {
+pub bh1: tpacket_hdr_v1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_req_u {
+pub req: tpacket_req,
+pub req3: tpacket_req3,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/image.rs

@@ -0,0 +1,3 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/io_uring.rs

@@ -0,0 +1,1442 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type __kernel_rwf_t = crate::ctypes::c_int;
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v1 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub master_key_descriptor: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_key {
+pub mode: __u32,
+pub raw: [__u8; 64usize],
+pub size: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v2 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub log2_data_unit_size: __u8,
+pub __reserved: [__u8; 3usize],
+pub master_key_identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_policy_ex_arg {
+pub policy_size: __u64,
+pub policy: fscrypt_get_policy_ex_arg__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_key_specifier {
+pub type_: __u32,
+pub __reserved: __u32,
+pub u: fscrypt_key_specifier__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct fscrypt_provisioning_key_payload {
+pub type_: __u32,
+pub flags: __u32,
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+pub struct fscrypt_add_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub raw_size: __u32,
+pub key_id: __u32,
+pub flags: __u32,
+pub __reserved: [__u32; 7usize],
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_remove_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub removal_status_flags: __u32,
+pub __reserved: [__u32; 5usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_key_status_arg {
+pub key_spec: fscrypt_key_specifier,
+pub __reserved: [__u32; 6usize],
+pub status: __u32,
+pub status_flags: __u32,
+pub user_count: __u32,
+pub __out_reserved: [__u32; 13usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mount_attr {
+pub attr_set: __u64,
+pub attr_clr: __u64,
+pub propagation: __u64,
+pub userns_fd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct statmount {
+pub size: __u32,
+pub mnt_opts: __u32,
+pub mask: __u64,
+pub sb_dev_major: __u32,
+pub sb_dev_minor: __u32,
+pub sb_magic: __u64,
+pub sb_flags: __u32,
+pub fs_type: __u32,
+pub mnt_id: __u64,
+pub mnt_parent_id: __u64,
+pub mnt_id_old: __u32,
+pub mnt_parent_id_old: __u32,
+pub mnt_attr: __u64,
+pub mnt_propagation: __u64,
+pub mnt_peer_group: __u64,
+pub mnt_master: __u64,
+pub propagate_from: __u64,
+pub mnt_root: __u32,
+pub mnt_point: __u32,
+pub mnt_ns_id: __u64,
+pub fs_subtype: __u32,
+pub sb_source: __u32,
+pub opt_num: __u32,
+pub opt_array: __u32,
+pub opt_sec_num: __u32,
+pub opt_sec_array: __u32,
+pub supported_mask: __u64,
+pub mnt_uidmap_num: __u32,
+pub mnt_uidmap: __u32,
+pub mnt_gidmap_num: __u32,
+pub mnt_gidmap: __u32,
+pub __spare2: [__u64; 43usize],
+pub str_: __IncompleteArrayField<crate::ctypes::c_char>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mnt_id_req {
+pub size: __u32,
+pub spare: __u32,
+pub mnt_id: __u64,
+pub param: __u64,
+pub mnt_ns_id: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_clone_range {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fstrim_range {
+pub start: __u64,
+pub len: __u64,
+pub minlen: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsuuid2 {
+pub len: __u8,
+pub uuid: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fs_sysfs_path {
+pub len: __u8,
+pub name: [__u8; 128usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_dedupe_range_info {
+pub dest_fd: __s64,
+pub dest_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct file_dedupe_range {
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<file_dedupe_range_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct files_stat_struct {
+pub nr_files: crate::ctypes::c_ulong,
+pub nr_free_files: crate::ctypes::c_ulong,
+pub max_files: crate::ctypes::c_ulong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct inodes_stat_t {
+pub nr_inodes: crate::ctypes::c_long,
+pub nr_unused: crate::ctypes::c_long,
+pub dummy: [crate::ctypes::c_long; 5usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsxattr {
+pub fsx_xflags: __u32,
+pub fsx_extsize: __u32,
+pub fsx_nextents: __u32,
+pub fsx_projid: __u32,
+pub fsx_cowextsize: __u32,
+pub fsx_pad: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct page_region {
+pub start: __u64,
+pub end: __u64,
+pub categories: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct pm_scan_arg {
+pub size: __u64,
+pub flags: __u64,
+pub start: __u64,
+pub end: __u64,
+pub walk_end: __u64,
+pub vec: __u64,
+pub vec_len: __u64,
+pub max_pages: __u64,
+pub category_inverted: __u64,
+pub category_mask: __u64,
+pub category_anyof_mask: __u64,
+pub return_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct procmap_query {
+pub size: __u64,
+pub query_flags: __u64,
+pub query_addr: __u64,
+pub vma_start: __u64,
+pub vma_end: __u64,
+pub vma_flags: __u64,
+pub vma_page_size: __u64,
+pub vma_offset: __u64,
+pub inode: __u64,
+pub dev_major: __u32,
+pub dev_minor: __u32,
+pub vma_name_size: __u32,
+pub build_id_size: __u32,
+pub vma_name_addr: __u64,
+pub build_id_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_timespec {
+pub tv_sec: __kernel_time64_t,
+pub tv_nsec: crate::ctypes::c_longlong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_itimerspec {
+pub it_interval: __kernel_timespec,
+pub it_value: __kernel_timespec,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_timeval {
+pub tv_sec: __kernel_long_t,
+pub tv_usec: __kernel_long_t,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_timespec {
+pub tv_sec: __kernel_old_time_t,
+pub tv_nsec: crate::ctypes::c_long,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_itimerval {
+pub it_interval: __kernel_old_timeval,
+pub it_value: __kernel_old_timeval,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_sock_timeval {
+pub tv_sec: __s64,
+pub tv_usec: __s64,
+}
+#[repr(C)]
+pub struct io_uring_sqe {
+pub opcode: __u8,
+pub flags: __u8,
+pub ioprio: __u16,
+pub fd: __s32,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1,
+pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_2,
+pub len: __u32,
+pub __bindgen_anon_3: io_uring_sqe__bindgen_ty_3,
+pub user_data: __u64,
+pub __bindgen_anon_4: io_uring_sqe__bindgen_ty_4,
+pub personality: __u16,
+pub __bindgen_anon_5: io_uring_sqe__bindgen_ty_5,
+pub __bindgen_anon_6: io_uring_sqe__bindgen_ty_6,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_1__bindgen_ty_1 {
+pub cmd_op: __u32,
+pub __pad1: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_2__bindgen_ty_1 {
+pub level: __u32,
+pub optname: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_1 {
+pub addr_len: __u16,
+pub __pad3: [__u16; 1usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_2 {
+pub write_stream: __u8,
+pub __pad4: [__u8; 3usize],
+}
+#[repr(C)]
+pub struct io_uring_sqe__bindgen_ty_6 {
+pub __bindgen_anon_1: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>,
+pub __bindgen_anon_2: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_2>,
+pub optval: __BindgenUnionField<__u64>,
+pub cmd: __BindgenUnionField<[__u8; 0usize]>,
+pub bindgen_union_field: [u32; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_1 {
+pub addr3: __u64,
+pub __pad2: [__u64; 1usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_2 {
+pub attr_ptr: __u64,
+pub attr_type_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_attr_pi {
+pub flags: __u16,
+pub app_tag: __u16,
+pub len: __u32,
+pub addr: __u64,
+pub seed: __u64,
+pub rsvd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_cqe {
+pub user_data: __u64,
+pub res: __s32,
+pub flags: __u32,
+pub big_cqe: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_sqring_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub ring_mask: __u32,
+pub ring_entries: __u32,
+pub flags: __u32,
+pub dropped: __u32,
+pub array: __u32,
+pub resv1: __u32,
+pub user_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_cqring_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub ring_mask: __u32,
+pub ring_entries: __u32,
+pub overflow: __u32,
+pub cqes: __u32,
+pub flags: __u32,
+pub resv1: __u32,
+pub user_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_params {
+pub sq_entries: __u32,
+pub cq_entries: __u32,
+pub flags: __u32,
+pub sq_thread_cpu: __u32,
+pub sq_thread_idle: __u32,
+pub features: __u32,
+pub wq_fd: __u32,
+pub resv: [__u32; 3usize],
+pub sq_off: io_sqring_offsets,
+pub cq_off: io_cqring_offsets,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_files_update {
+pub offset: __u32,
+pub resv: __u32,
+pub fds: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_region_desc {
+pub user_addr: __u64,
+pub size: __u64,
+pub flags: __u32,
+pub id: __u32,
+pub mmap_offset: __u64,
+pub __resv: [__u64; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_mem_region_reg {
+pub region_uptr: __u64,
+pub flags: __u64,
+pub __resv: [__u64; 2usize],
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_register {
+pub nr: __u32,
+pub flags: __u32,
+pub resv2: __u64,
+pub data: __u64,
+pub tags: __u64,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_update {
+pub offset: __u32,
+pub resv: __u32,
+pub data: __u64,
+}
+#[repr(C)]
+#[repr(align(8))]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_update2 {
+pub offset: __u32,
+pub resv: __u32,
+pub data: __u64,
+pub tags: __u64,
+pub nr: __u32,
+pub resv2: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_probe_op {
+pub op: __u8,
+pub resv: __u8,
+pub flags: __u16,
+pub resv2: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_probe {
+pub last_op: __u8,
+pub ops_len: __u8,
+pub resv: __u16,
+pub resv2: [__u32; 3usize],
+pub ops: __IncompleteArrayField<io_uring_probe_op>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct io_uring_restriction {
+pub opcode: __u16,
+pub __bindgen_anon_1: io_uring_restriction__bindgen_ty_1,
+pub resv: __u8,
+pub resv2: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_clock_register {
+pub clockid: __u32,
+pub __resv: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_clone_buffers {
+pub src_fd: __u32,
+pub flags: __u32,
+pub src_off: __u32,
+pub dst_off: __u32,
+pub nr: __u32,
+pub pad: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf {
+pub addr: __u64,
+pub len: __u32,
+pub bid: __u16,
+pub resv: __u16,
+}
+#[repr(C)]
+pub struct io_uring_buf_ring {
+pub __bindgen_anon_1: io_uring_buf_ring__bindgen_ty_1,
+}
+#[repr(C)]
+pub struct io_uring_buf_ring__bindgen_ty_1 {
+pub __bindgen_anon_1: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>,
+pub __bindgen_anon_2: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>,
+pub bindgen_union_field: [u32; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1 {
+pub resv1: __u64,
+pub resv2: __u32,
+pub resv3: __u16,
+pub tail: __u16,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2 {
+pub __empty_bufs: io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
+pub bufs: __IncompleteArrayField<io_uring_buf>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_reg {
+pub ring_addr: __u64,
+pub ring_entries: __u32,
+pub bgid: __u16,
+pub flags: __u16,
+pub resv: [__u64; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_status {
+pub buf_group: __u32,
+pub head: __u32,
+pub resv: [__u32; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_napi {
+pub busy_poll_to: __u32,
+pub prefer_busy_poll: __u8,
+pub opcode: __u8,
+pub pad: [__u8; 2usize],
+pub op_param: __u32,
+pub resv: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_reg_wait {
+pub ts: __kernel_timespec,
+pub min_wait_usec: __u32,
+pub flags: __u32,
+pub sigmask: __u64,
+pub sigmask_sz: __u32,
+pub pad: [__u32; 3usize],
+pub pad2: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_getevents_arg {
+pub sigmask: __u64,
+pub sigmask_sz: __u32,
+pub min_wait_usec: __u32,
+pub ts: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sync_cancel_reg {
+pub addr: __u64,
+pub fd: __s32,
+pub flags: __u32,
+pub timeout: __kernel_timespec,
+pub opcode: __u8,
+pub pad: [__u8; 7usize],
+pub pad2: [__u64; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_file_index_range {
+pub off: __u32,
+pub len: __u32,
+pub resv: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_recvmsg_out {
+pub namelen: __u32,
+pub controllen: __u32,
+pub payloadlen: __u32,
+pub flags: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_rqe {
+pub off: __u64,
+pub len: __u32,
+pub __pad: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_cqe {
+pub off: __u64,
+pub __pad: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub rqes: __u32,
+pub __resv2: __u32,
+pub __resv: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_area_reg {
+pub addr: __u64,
+pub len: __u64,
+pub rq_area_token: __u64,
+pub flags: __u32,
+pub dmabuf_fd: __u32,
+pub __resv2: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_ifq_reg {
+pub if_idx: __u32,
+pub if_rxq: __u32,
+pub rq_entries: __u32,
+pub flags: __u32,
+pub area_ptr: __u64,
+pub region_ptr: __u64,
+pub offsets: io_uring_zcrx_offsets,
+pub zcrx_id: __u32,
+pub __resv2: __u32,
+pub __resv: [__u64; 3usize],
+}
+pub const NR_OPEN: u32 = 1024;
+pub const NGROUPS_MAX: u32 = 65536;
+pub const ARG_MAX: u32 = 131072;
+pub const LINK_MAX: u32 = 127;
+pub const MAX_CANON: u32 = 255;
+pub const MAX_INPUT: u32 = 255;
+pub const NAME_MAX: u32 = 255;
+pub const PATH_MAX: u32 = 4096;
+pub const PIPE_BUF: u32 = 4096;
+pub const XATTR_NAME_MAX: u32 = 255;
+pub const XATTR_SIZE_MAX: u32 = 65536;
+pub const XATTR_LIST_MAX: u32 = 65536;
+pub const RTSIG_MAX: u32 = 32;
+pub const _IOC_NRBITS: u32 = 8;
+pub const _IOC_TYPEBITS: u32 = 8;
+pub const _IOC_SIZEBITS: u32 = 14;
+pub const _IOC_DIRBITS: u32 = 2;
+pub const _IOC_NRMASK: u32 = 255;
+pub const _IOC_TYPEMASK: u32 = 255;
+pub const _IOC_SIZEMASK: u32 = 16383;
+pub const _IOC_DIRMASK: u32 = 3;
+pub const _IOC_NRSHIFT: u32 = 0;
+pub const _IOC_TYPESHIFT: u32 = 8;
+pub const _IOC_SIZESHIFT: u32 = 16;
+pub const _IOC_DIRSHIFT: u32 = 30;
+pub const _IOC_NONE: u32 = 0;
+pub const _IOC_WRITE: u32 = 1;
+pub const _IOC_READ: u32 = 2;
+pub const IOC_IN: u32 = 1073741824;
+pub const IOC_OUT: u32 = 2147483648;
+pub const IOC_INOUT: u32 = 3221225472;
+pub const IOCSIZE_MASK: u32 = 1073676288;
+pub const IOCSIZE_SHIFT: u32 = 16;
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const FSCRYPT_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FSCRYPT_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FSCRYPT_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FSCRYPT_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FSCRYPT_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FSCRYPT_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64: u32 = 8;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32: u32 = 16;
+pub const FSCRYPT_MODE_AES_256_XTS: u32 = 1;
+pub const FSCRYPT_MODE_AES_256_CTS: u32 = 4;
+pub const FSCRYPT_MODE_AES_128_CBC: u32 = 5;
+pub const FSCRYPT_MODE_AES_128_CTS: u32 = 6;
+pub const FSCRYPT_MODE_SM4_XTS: u32 = 7;
+pub const FSCRYPT_MODE_SM4_CTS: u32 = 8;
+pub const FSCRYPT_MODE_ADIANTUM: u32 = 9;
+pub const FSCRYPT_MODE_AES_256_HCTR2: u32 = 10;
+pub const FSCRYPT_POLICY_V1: u32 = 0;
+pub const FSCRYPT_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FSCRYPT_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FSCRYPT_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FSCRYPT_MAX_KEY_SIZE: u32 = 64;
+pub const FSCRYPT_POLICY_V2: u32 = 2;
+pub const FSCRYPT_KEY_IDENTIFIER_SIZE: u32 = 16;
+pub const FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: u32 = 1;
+pub const FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: u32 = 2;
+pub const FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSY: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERS: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_ABSENT: u32 = 1;
+pub const FSCRYPT_KEY_STATUS_PRESENT: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVED: u32 = 3;
+pub const FSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELF: u32 = 1;
+pub const FS_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FS_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FS_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FS_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FS_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FS_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FS_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FS_POLICY_FLAGS_VALID: u32 = 7;
+pub const FS_ENCRYPTION_MODE_INVALID: u32 = 0;
+pub const FS_ENCRYPTION_MODE_AES_256_XTS: u32 = 1;
+pub const FS_ENCRYPTION_MODE_AES_256_GCM: u32 = 2;
+pub const FS_ENCRYPTION_MODE_AES_256_CBC: u32 = 3;
+pub const FS_ENCRYPTION_MODE_AES_256_CTS: u32 = 4;
+pub const FS_ENCRYPTION_MODE_AES_128_CBC: u32 = 5;
+pub const FS_ENCRYPTION_MODE_AES_128_CTS: u32 = 6;
+pub const FS_ENCRYPTION_MODE_ADIANTUM: u32 = 9;
+pub const FS_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FS_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FS_MAX_KEY_SIZE: u32 = 64;
+pub const MS_RDONLY: u32 = 1;
+pub const MS_NOSUID: u32 = 2;
+pub const MS_NODEV: u32 = 4;
+pub const MS_NOEXEC: u32 = 8;
+pub const MS_SYNCHRONOUS: u32 = 16;
+pub const MS_REMOUNT: u32 = 32;
+pub const MS_MANDLOCK: u32 = 64;
+pub const MS_DIRSYNC: u32 = 128;
+pub const MS_NOSYMFOLLOW: u32 = 256;
+pub const MS_NOATIME: u32 = 1024;
+pub const MS_NODIRATIME: u32 = 2048;
+pub const MS_BIND: u32 = 4096;
+pub const MS_MOVE: u32 = 8192;
+pub const MS_REC: u32 = 16384;
+pub const MS_VERBOSE: u32 = 32768;
+pub const MS_SILENT: u32 = 32768;
+pub const MS_POSIXACL: u32 = 65536;
+pub const MS_UNBINDABLE: u32 = 131072;
+pub const MS_PRIVATE: u32 = 262144;
+pub const MS_SLAVE: u32 = 524288;
+pub const MS_SHARED: u32 = 1048576;
+pub const MS_RELATIME: u32 = 2097152;
+pub const MS_KERNMOUNT: u32 = 4194304;
+pub const MS_I_VERSION: u32 = 8388608;
+pub const MS_STRICTATIME: u32 = 16777216;
+pub const MS_LAZYTIME: u32 = 33554432;
+pub const MS_SUBMOUNT: u32 = 67108864;
+pub const MS_NOREMOTELOCK: u32 = 134217728;
+pub const MS_NOSEC: u32 = 268435456;
+pub const MS_BORN: u32 = 536870912;
+pub const MS_ACTIVE: u32 = 1073741824;
+pub const MS_NOUSER: u32 = 2147483648;
+pub const MS_RMT_MASK: u32 = 41943121;
+pub const MS_MGC_VAL: u32 = 3236757504;
+pub const MS_MGC_MSK: u32 = 4294901760;
+pub const OPEN_TREE_CLONE: u32 = 1;
+pub const MOVE_MOUNT_F_SYMLINKS: u32 = 1;
+pub const MOVE_MOUNT_F_AUTOMOUNTS: u32 = 2;
+pub const MOVE_MOUNT_F_EMPTY_PATH: u32 = 4;
+pub const MOVE_MOUNT_T_SYMLINKS: u32 = 16;
+pub const MOVE_MOUNT_T_AUTOMOUNTS: u32 = 32;
+pub const MOVE_MOUNT_T_EMPTY_PATH: u32 = 64;
+pub const MOVE_MOUNT_SET_GROUP: u32 = 256;
+pub const MOVE_MOUNT_BENEATH: u32 = 512;
+pub const MOVE_MOUNT__MASK: u32 = 887;
+pub const FSOPEN_CLOEXEC: u32 = 1;
+pub const FSPICK_CLOEXEC: u32 = 1;
+pub const FSPICK_SYMLINK_NOFOLLOW: u32 = 2;
+pub const FSPICK_NO_AUTOMOUNT: u32 = 4;
+pub const FSPICK_EMPTY_PATH: u32 = 8;
+pub const FSMOUNT_CLOEXEC: u32 = 1;
+pub const MOUNT_ATTR_RDONLY: u32 = 1;
+pub const MOUNT_ATTR_NOSUID: u32 = 2;
+pub const MOUNT_ATTR_NODEV: u32 = 4;
+pub const MOUNT_ATTR_NOEXEC: u32 = 8;
+pub const MOUNT_ATTR__ATIME: u32 = 112;
+pub const MOUNT_ATTR_RELATIME: u32 = 0;
+pub const MOUNT_ATTR_NOATIME: u32 = 16;
+pub const MOUNT_ATTR_STRICTATIME: u32 = 32;
+pub const MOUNT_ATTR_NODIRATIME: u32 = 128;
+pub const MOUNT_ATTR_IDMAP: u32 = 1048576;
+pub const MOUNT_ATTR_NOSYMFOLLOW: u32 = 2097152;
+pub const MOUNT_ATTR_SIZE_VER0: u32 = 32;
+pub const MNT_ID_REQ_SIZE_VER0: u32 = 24;
+pub const MNT_ID_REQ_SIZE_VER1: u32 = 32;
+pub const STATMOUNT_SB_BASIC: u32 = 1;
+pub const STATMOUNT_MNT_BASIC: u32 = 2;
+pub const STATMOUNT_PROPAGATE_FROM: u32 = 4;
+pub const STATMOUNT_MNT_ROOT: u32 = 8;
+pub const STATMOUNT_MNT_POINT: u32 = 16;
+pub const STATMOUNT_FS_TYPE: u32 = 32;
+pub const STATMOUNT_MNT_NS_ID: u32 = 64;
+pub const STATMOUNT_MNT_OPTS: u32 = 128;
+pub const STATMOUNT_FS_SUBTYPE: u32 = 256;
+pub const STATMOUNT_SB_SOURCE: u32 = 512;
+pub const STATMOUNT_OPT_ARRAY: u32 = 1024;
+pub const STATMOUNT_OPT_SEC_ARRAY: u32 = 2048;
+pub const STATMOUNT_SUPPORTED_MASK: u32 = 4096;
+pub const STATMOUNT_MNT_UIDMAP: u32 = 8192;
+pub const STATMOUNT_MNT_GIDMAP: u32 = 16384;
+pub const LSMT_ROOT: i32 = -1;
+pub const LISTMOUNT_REVERSE: u32 = 1;
+pub const INR_OPEN_CUR: u32 = 1024;
+pub const INR_OPEN_MAX: u32 = 4096;
+pub const BLOCK_SIZE_BITS: u32 = 10;
+pub const BLOCK_SIZE: u32 = 1024;
+pub const IO_INTEGRITY_CHK_GUARD: u32 = 1;
+pub const IO_INTEGRITY_CHK_REFTAG: u32 = 2;
+pub const IO_INTEGRITY_CHK_APPTAG: u32 = 4;
+pub const IO_INTEGRITY_VALID_FLAGS: u32 = 7;
+pub const SEEK_SET: u32 = 0;
+pub const SEEK_CUR: u32 = 1;
+pub const SEEK_END: u32 = 2;
+pub const SEEK_DATA: u32 = 3;
+pub const SEEK_HOLE: u32 = 4;
+pub const SEEK_MAX: u32 = 4;
+pub const RENAME_NOREPLACE: u32 = 1;
+pub const RENAME_EXCHANGE: u32 = 2;
+pub const RENAME_WHITEOUT: u32 = 4;
+pub const FILE_DEDUPE_RANGE_SAME: u32 = 0;
+pub const FILE_DEDUPE_RANGE_DIFFERS: u32 = 1;
+pub const NR_FILE: u32 = 8192;
+pub const FS_XFLAG_REALTIME: u32 = 1;
+pub const FS_XFLAG_PREALLOC: u32 = 2;
+pub const FS_XFLAG_IMMUTABLE: u32 = 8;
+pub const FS_XFLAG_APPEND: u32 = 16;
+pub const FS_XFLAG_SYNC: u32 = 32;
+pub const FS_XFLAG_NOATIME: u32 = 64;
+pub const FS_XFLAG_NODUMP: u32 = 128;
+pub const FS_XFLAG_RTINHERIT: u32 = 256;
+pub const FS_XFLAG_PROJINHERIT: u32 = 512;
+pub const FS_XFLAG_NOSYMLINKS: u32 = 1024;
+pub const FS_XFLAG_EXTSIZE: u32 = 2048;
+pub const FS_XFLAG_EXTSZINHERIT: u32 = 4096;
+pub const FS_XFLAG_NODEFRAG: u32 = 8192;
+pub const FS_XFLAG_FILESTREAM: u32 = 16384;
+pub const FS_XFLAG_DAX: u32 = 32768;
+pub const FS_XFLAG_COWEXTSIZE: u32 = 65536;
+pub const FS_XFLAG_HASATTR: u32 = 2147483648;
+pub const BMAP_IOCTL: u32 = 1;
+pub const FSLABEL_MAX: u32 = 256;
+pub const FS_SECRM_FL: u32 = 1;
+pub const FS_UNRM_FL: u32 = 2;
+pub const FS_COMPR_FL: u32 = 4;
+pub const FS_SYNC_FL: u32 = 8;
+pub const FS_IMMUTABLE_FL: u32 = 16;
+pub const FS_APPEND_FL: u32 = 32;
+pub const FS_NODUMP_FL: u32 = 64;
+pub const FS_NOATIME_FL: u32 = 128;
+pub const FS_DIRTY_FL: u32 = 256;
+pub const FS_COMPRBLK_FL: u32 = 512;
+pub const FS_NOCOMP_FL: u32 = 1024;
+pub const FS_ENCRYPT_FL: u32 = 2048;
+pub const FS_BTREE_FL: u32 = 4096;
+pub const FS_INDEX_FL: u32 = 4096;
+pub const FS_IMAGIC_FL: u32 = 8192;
+pub const FS_JOURNAL_DATA_FL: u32 = 16384;
+pub const FS_NOTAIL_FL: u32 = 32768;
+pub const FS_DIRSYNC_FL: u32 = 65536;
+pub const FS_TOPDIR_FL: u32 = 131072;
+pub const FS_HUGE_FILE_FL: u32 = 262144;
+pub const FS_EXTENT_FL: u32 = 524288;
+pub const FS_VERITY_FL: u32 = 1048576;
+pub const FS_EA_INODE_FL: u32 = 2097152;
+pub const FS_EOFBLOCKS_FL: u32 = 4194304;
+pub const FS_NOCOW_FL: u32 = 8388608;
+pub const FS_DAX_FL: u32 = 33554432;
+pub const FS_INLINE_DATA_FL: u32 = 268435456;
+pub const FS_PROJINHERIT_FL: u32 = 536870912;
+pub const FS_CASEFOLD_FL: u32 = 1073741824;
+pub const FS_RESERVED_FL: u32 = 2147483648;
+pub const FS_FL_USER_VISIBLE: u32 = 253951;
+pub const FS_FL_USER_MODIFIABLE: u32 = 229631;
+pub const SYNC_FILE_RANGE_WAIT_BEFORE: u32 = 1;
+pub const SYNC_FILE_RANGE_WRITE: u32 = 2;
+pub const SYNC_FILE_RANGE_WAIT_AFTER: u32 = 4;
+pub const SYNC_FILE_RANGE_WRITE_AND_WAIT: u32 = 7;
+pub const PROCFS_IOCTL_MAGIC: u8 = 102u8;
+pub const PAGE_IS_WPALLOWED: u32 = 1;
+pub const PAGE_IS_WRITTEN: u32 = 2;
+pub const PAGE_IS_FILE: u32 = 4;
+pub const PAGE_IS_PRESENT: u32 = 8;
+pub const PAGE_IS_SWAPPED: u32 = 16;
+pub const PAGE_IS_PFNZERO: u32 = 32;
+pub const PAGE_IS_HUGE: u32 = 64;
+pub const PAGE_IS_SOFT_DIRTY: u32 = 128;
+pub const PAGE_IS_GUARD: u32 = 256;
+pub const PM_SCAN_WP_MATCHING: u32 = 1;
+pub const PM_SCAN_CHECK_WPASYNC: u32 = 2;
+pub const IORING_RW_ATTR_FLAG_PI: u32 = 1;
+pub const IORING_FILE_INDEX_ALLOC: i32 = -1;
+pub const IORING_SETUP_IOPOLL: u32 = 1;
+pub const IORING_SETUP_SQPOLL: u32 = 2;
+pub const IORING_SETUP_SQ_AFF: u32 = 4;
+pub const IORING_SETUP_CQSIZE: u32 = 8;
+pub const IORING_SETUP_CLAMP: u32 = 16;
+pub const IORING_SETUP_ATTACH_WQ: u32 = 32;
+pub const IORING_SETUP_R_DISABLED: u32 = 64;
+pub const IORING_SETUP_SUBMIT_ALL: u32 = 128;
+pub const IORING_SETUP_COOP_TASKRUN: u32 = 256;
+pub const IORING_SETUP_TASKRUN_FLAG: u32 = 512;
+pub const IORING_SETUP_SQE128: u32 = 1024;
+pub const IORING_SETUP_CQE32: u32 = 2048;
+pub const IORING_SETUP_SINGLE_ISSUER: u32 = 4096;
+pub const IORING_SETUP_DEFER_TASKRUN: u32 = 8192;
+pub const IORING_SETUP_NO_MMAP: u32 = 16384;
+pub const IORING_SETUP_REGISTERED_FD_ONLY: u32 = 32768;
+pub const IORING_SETUP_NO_SQARRAY: u32 = 65536;
+pub const IORING_SETUP_HYBRID_IOPOLL: u32 = 131072;
+pub const IORING_URING_CMD_FIXED: u32 = 1;
+pub const IORING_URING_CMD_MASK: u32 = 1;
+pub const IORING_FSYNC_DATASYNC: u32 = 1;
+pub const IORING_TIMEOUT_ABS: u32 = 1;
+pub const IORING_TIMEOUT_UPDATE: u32 = 2;
+pub const IORING_TIMEOUT_BOOTTIME: u32 = 4;
+pub const IORING_TIMEOUT_REALTIME: u32 = 8;
+pub const IORING_LINK_TIMEOUT_UPDATE: u32 = 16;
+pub const IORING_TIMEOUT_ETIME_SUCCESS: u32 = 32;
+pub const IORING_TIMEOUT_MULTISHOT: u32 = 64;
+pub const IORING_TIMEOUT_CLOCK_MASK: u32 = 12;
+pub const IORING_TIMEOUT_UPDATE_MASK: u32 = 18;
+pub const SPLICE_F_FD_IN_FIXED: u32 = 2147483648;
+pub const IORING_POLL_ADD_MULTI: u32 = 1;
+pub const IORING_POLL_UPDATE_EVENTS: u32 = 2;
+pub const IORING_POLL_UPDATE_USER_DATA: u32 = 4;
+pub const IORING_POLL_ADD_LEVEL: u32 = 8;
+pub const IORING_ASYNC_CANCEL_ALL: u32 = 1;
+pub const IORING_ASYNC_CANCEL_FD: u32 = 2;
+pub const IORING_ASYNC_CANCEL_ANY: u32 = 4;
+pub const IORING_ASYNC_CANCEL_FD_FIXED: u32 = 8;
+pub const IORING_ASYNC_CANCEL_USERDATA: u32 = 16;
+pub const IORING_ASYNC_CANCEL_OP: u32 = 32;
+pub const IORING_RECVSEND_POLL_FIRST: u32 = 1;
+pub const IORING_RECV_MULTISHOT: u32 = 2;
+pub const IORING_RECVSEND_FIXED_BUF: u32 = 4;
+pub const IORING_SEND_ZC_REPORT_USAGE: u32 = 8;
+pub const IORING_RECVSEND_BUNDLE: u32 = 16;
+pub const IORING_NOTIF_USAGE_ZC_COPIED: u32 = 2147483648;
+pub const IORING_ACCEPT_MULTISHOT: u32 = 1;
+pub const IORING_ACCEPT_DONTWAIT: u32 = 2;
+pub const IORING_ACCEPT_POLL_FIRST: u32 = 4;
+pub const IORING_MSG_RING_CQE_SKIP: u32 = 1;
+pub const IORING_MSG_RING_FLAGS_PASS: u32 = 2;
+pub const IORING_FIXED_FD_NO_CLOEXEC: u32 = 1;
+pub const IORING_NOP_INJECT_RESULT: u32 = 1;
+pub const IORING_NOP_FILE: u32 = 2;
+pub const IORING_NOP_FIXED_FILE: u32 = 4;
+pub const IORING_NOP_FIXED_BUFFER: u32 = 8;
+pub const IORING_CQE_F_BUFFER: u32 = 1;
+pub const IORING_CQE_F_MORE: u32 = 2;
+pub const IORING_CQE_F_SOCK_NONEMPTY: u32 = 4;
+pub const IORING_CQE_F_NOTIF: u32 = 8;
+pub const IORING_CQE_F_BUF_MORE: u32 = 16;
+pub const IORING_CQE_BUFFER_SHIFT: u32 = 16;
+pub const IORING_OFF_SQ_RING: u32 = 0;
+pub const IORING_OFF_CQ_RING: u32 = 134217728;
+pub const IORING_OFF_SQES: u32 = 268435456;
+pub const IORING_OFF_PBUF_RING: u32 = 2147483648;
+pub const IORING_OFF_PBUF_SHIFT: u32 = 16;
+pub const IORING_OFF_MMAP_MASK: u32 = 4160749568;
+pub const IORING_SQ_NEED_WAKEUP: u32 = 1;
+pub const IORING_SQ_CQ_OVERFLOW: u32 = 2;
+pub const IORING_SQ_TASKRUN: u32 = 4;
+pub const IORING_CQ_EVENTFD_DISABLED: u32 = 1;
+pub const IORING_ENTER_GETEVENTS: u32 = 1;
+pub const IORING_ENTER_SQ_WAKEUP: u32 = 2;
+pub const IORING_ENTER_SQ_WAIT: u32 = 4;
+pub const IORING_ENTER_EXT_ARG: u32 = 8;
+pub const IORING_ENTER_REGISTERED_RING: u32 = 16;
+pub const IORING_ENTER_ABS_TIMER: u32 = 32;
+pub const IORING_ENTER_EXT_ARG_REG: u32 = 64;
+pub const IORING_ENTER_NO_IOWAIT: u32 = 128;
+pub const IORING_FEAT_SINGLE_MMAP: u32 = 1;
+pub const IORING_FEAT_NODROP: u32 = 2;
+pub const IORING_FEAT_SUBMIT_STABLE: u32 = 4;
+pub const IORING_FEAT_RW_CUR_POS: u32 = 8;
+pub const IORING_FEAT_CUR_PERSONALITY: u32 = 16;
+pub const IORING_FEAT_FAST_POLL: u32 = 32;
+pub const IORING_FEAT_POLL_32BITS: u32 = 64;
+pub const IORING_FEAT_SQPOLL_NONFIXED: u32 = 128;
+pub const IORING_FEAT_EXT_ARG: u32 = 256;
+pub const IORING_FEAT_NATIVE_WORKERS: u32 = 512;
+pub const IORING_FEAT_RSRC_TAGS: u32 = 1024;
+pub const IORING_FEAT_CQE_SKIP: u32 = 2048;
+pub const IORING_FEAT_LINKED_FILE: u32 = 4096;
+pub const IORING_FEAT_REG_REG_RING: u32 = 8192;
+pub const IORING_FEAT_RECVSEND_BUNDLE: u32 = 16384;
+pub const IORING_FEAT_MIN_TIMEOUT: u32 = 32768;
+pub const IORING_FEAT_RW_ATTR: u32 = 65536;
+pub const IORING_FEAT_NO_IOWAIT: u32 = 131072;
+pub const IORING_RSRC_REGISTER_SPARSE: u32 = 1;
+pub const IORING_REGISTER_FILES_SKIP: i32 = -2;
+pub const IO_URING_OP_SUPPORTED: u32 = 1;
+pub const IORING_ZCRX_AREA_SHIFT: u32 = 48;
+pub const IORING_MEM_REGION_TYPE_USER: _bindgen_ty_1 = _bindgen_ty_1::IORING_MEM_REGION_TYPE_USER;
+pub const IORING_MEM_REGION_REG_WAIT_ARG: _bindgen_ty_2 = _bindgen_ty_2::IORING_MEM_REGION_REG_WAIT_ARG;
+pub const IORING_REGISTER_SRC_REGISTERED: _bindgen_ty_3 = _bindgen_ty_3::IORING_REGISTER_SRC_REGISTERED;
+pub const IORING_REGISTER_DST_REPLACE: _bindgen_ty_3 = _bindgen_ty_3::IORING_REGISTER_DST_REPLACE;
+pub const IORING_REG_WAIT_TS: _bindgen_ty_4 = _bindgen_ty_4::IORING_REG_WAIT_TS;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum fsconfig_command {
+FSCONFIG_SET_FLAG = 0,
+FSCONFIG_SET_STRING = 1,
+FSCONFIG_SET_BINARY = 2,
+FSCONFIG_SET_PATH = 3,
+FSCONFIG_SET_PATH_EMPTY = 4,
+FSCONFIG_SET_FD = 5,
+FSCONFIG_CMD_CREATE = 6,
+FSCONFIG_CMD_RECONFIGURE = 7,
+FSCONFIG_CMD_CREATE_EXCL = 8,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum procmap_query_flags {
+PROCMAP_QUERY_VMA_READABLE = 1,
+PROCMAP_QUERY_VMA_WRITABLE = 2,
+PROCMAP_QUERY_VMA_EXECUTABLE = 4,
+PROCMAP_QUERY_VMA_SHARED = 8,
+PROCMAP_QUERY_COVERING_OR_NEXT_VMA = 16,
+PROCMAP_QUERY_FILE_BACKED_VMA = 32,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_sqe_flags_bit {
+IOSQE_FIXED_FILE_BIT = 0,
+IOSQE_IO_DRAIN_BIT = 1,
+IOSQE_IO_LINK_BIT = 2,
+IOSQE_IO_HARDLINK_BIT = 3,
+IOSQE_ASYNC_BIT = 4,
+IOSQE_BUFFER_SELECT_BIT = 5,
+IOSQE_CQE_SKIP_SUCCESS_BIT = 6,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_op {
+IORING_OP_NOP = 0,
+IORING_OP_READV = 1,
+IORING_OP_WRITEV = 2,
+IORING_OP_FSYNC = 3,
+IORING_OP_READ_FIXED = 4,
+IORING_OP_WRITE_FIXED = 5,
+IORING_OP_POLL_ADD = 6,
+IORING_OP_POLL_REMOVE = 7,
+IORING_OP_SYNC_FILE_RANGE = 8,
+IORING_OP_SENDMSG = 9,
+IORING_OP_RECVMSG = 10,
+IORING_OP_TIMEOUT = 11,
+IORING_OP_TIMEOUT_REMOVE = 12,
+IORING_OP_ACCEPT = 13,
+IORING_OP_ASYNC_CANCEL = 14,
+IORING_OP_LINK_TIMEOUT = 15,
+IORING_OP_CONNECT = 16,
+IORING_OP_FALLOCATE = 17,
+IORING_OP_OPENAT = 18,
+IORING_OP_CLOSE = 19,
+IORING_OP_FILES_UPDATE = 20,
+IORING_OP_STATX = 21,
+IORING_OP_READ = 22,
+IORING_OP_WRITE = 23,
+IORING_OP_FADVISE = 24,
+IORING_OP_MADVISE = 25,
+IORING_OP_SEND = 26,
+IORING_OP_RECV = 27,
+IORING_OP_OPENAT2 = 28,
+IORING_OP_EPOLL_CTL = 29,
+IORING_OP_SPLICE = 30,
+IORING_OP_PROVIDE_BUFFERS = 31,
+IORING_OP_REMOVE_BUFFERS = 32,
+IORING_OP_TEE = 33,
+IORING_OP_SHUTDOWN = 34,
+IORING_OP_RENAMEAT = 35,
+IORING_OP_UNLINKAT = 36,
+IORING_OP_MKDIRAT = 37,
+IORING_OP_SYMLINKAT = 38,
+IORING_OP_LINKAT = 39,
+IORING_OP_MSG_RING = 40,
+IORING_OP_FSETXATTR = 41,
+IORING_OP_SETXATTR = 42,
+IORING_OP_FGETXATTR = 43,
+IORING_OP_GETXATTR = 44,
+IORING_OP_SOCKET = 45,
+IORING_OP_URING_CMD = 46,
+IORING_OP_SEND_ZC = 47,
+IORING_OP_SENDMSG_ZC = 48,
+IORING_OP_READ_MULTISHOT = 49,
+IORING_OP_WAITID = 50,
+IORING_OP_FUTEX_WAIT = 51,
+IORING_OP_FUTEX_WAKE = 52,
+IORING_OP_FUTEX_WAITV = 53,
+IORING_OP_FIXED_FD_INSTALL = 54,
+IORING_OP_FTRUNCATE = 55,
+IORING_OP_BIND = 56,
+IORING_OP_LISTEN = 57,
+IORING_OP_RECV_ZC = 58,
+IORING_OP_EPOLL_WAIT = 59,
+IORING_OP_READV_FIXED = 60,
+IORING_OP_WRITEV_FIXED = 61,
+IORING_OP_PIPE = 62,
+IORING_OP_LAST = 63,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_msg_ring_flags {
+IORING_MSG_DATA = 0,
+IORING_MSG_SEND_FD = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_op {
+IORING_REGISTER_BUFFERS = 0,
+IORING_UNREGISTER_BUFFERS = 1,
+IORING_REGISTER_FILES = 2,
+IORING_UNREGISTER_FILES = 3,
+IORING_REGISTER_EVENTFD = 4,
+IORING_UNREGISTER_EVENTFD = 5,
+IORING_REGISTER_FILES_UPDATE = 6,
+IORING_REGISTER_EVENTFD_ASYNC = 7,
+IORING_REGISTER_PROBE = 8,
+IORING_REGISTER_PERSONALITY = 9,
+IORING_UNREGISTER_PERSONALITY = 10,
+IORING_REGISTER_RESTRICTIONS = 11,
+IORING_REGISTER_ENABLE_RINGS = 12,
+IORING_REGISTER_FILES2 = 13,
+IORING_REGISTER_FILES_UPDATE2 = 14,
+IORING_REGISTER_BUFFERS2 = 15,
+IORING_REGISTER_BUFFERS_UPDATE = 16,
+IORING_REGISTER_IOWQ_AFF = 17,
+IORING_UNREGISTER_IOWQ_AFF = 18,
+IORING_REGISTER_IOWQ_MAX_WORKERS = 19,
+IORING_REGISTER_RING_FDS = 20,
+IORING_UNREGISTER_RING_FDS = 21,
+IORING_REGISTER_PBUF_RING = 22,
+IORING_UNREGISTER_PBUF_RING = 23,
+IORING_REGISTER_SYNC_CANCEL = 24,
+IORING_REGISTER_FILE_ALLOC_RANGE = 25,
+IORING_REGISTER_PBUF_STATUS = 26,
+IORING_REGISTER_NAPI = 27,
+IORING_UNREGISTER_NAPI = 28,
+IORING_REGISTER_CLOCK = 29,
+IORING_REGISTER_CLONE_BUFFERS = 30,
+IORING_REGISTER_SEND_MSG_RING = 31,
+IORING_REGISTER_ZCRX_IFQ = 32,
+IORING_REGISTER_RESIZE_RINGS = 33,
+IORING_REGISTER_MEM_REGION = 34,
+IORING_REGISTER_LAST = 35,
+IORING_REGISTER_USE_REGISTERED_RING = 2147483648,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_wq_type {
+IO_WQ_BOUND = 0,
+IO_WQ_UNBOUND = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+IORING_MEM_REGION_TYPE_USER = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_2 {
+IORING_MEM_REGION_REG_WAIT_ARG = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_3 {
+IORING_REGISTER_SRC_REGISTERED = 1,
+IORING_REGISTER_DST_REPLACE = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_pbuf_ring_flags {
+IOU_PBUF_RING_MMAP = 1,
+IOU_PBUF_RING_INC = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_napi_op {
+IO_URING_NAPI_REGISTER_OP = 0,
+IO_URING_NAPI_STATIC_ADD_ID = 1,
+IO_URING_NAPI_STATIC_DEL_ID = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_napi_tracking_strategy {
+IO_URING_NAPI_TRACKING_DYNAMIC = 0,
+IO_URING_NAPI_TRACKING_STATIC = 1,
+IO_URING_NAPI_TRACKING_INACTIVE = 255,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_restriction_op {
+IORING_RESTRICTION_REGISTER_OP = 0,
+IORING_RESTRICTION_SQE_OP = 1,
+IORING_RESTRICTION_SQE_FLAGS_ALLOWED = 2,
+IORING_RESTRICTION_SQE_FLAGS_REQUIRED = 3,
+IORING_RESTRICTION_LAST = 4,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_4 {
+IORING_REG_WAIT_TS = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_socket_op {
+SOCKET_URING_OP_SIOCINQ = 0,
+SOCKET_URING_OP_SIOCOUTQ = 1,
+SOCKET_URING_OP_GETSOCKOPT = 2,
+SOCKET_URING_OP_SETSOCKOPT = 3,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_zcrx_area_flags {
+IORING_ZCRX_AREA_DMABUF = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_get_policy_ex_arg__bindgen_ty_1 {
+pub version: __u8,
+pub v1: fscrypt_policy_v1,
+pub v2: fscrypt_policy_v2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_key_specifier__bindgen_ty_1 {
+pub __reserved: [__u8; 32usize],
+pub descriptor: [__u8; 8usize],
+pub identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_1 {
+pub off: __u64,
+pub addr2: __u64,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_2 {
+pub addr: __u64,
+pub splice_off_in: __u64,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_3 {
+pub rw_flags: __kernel_rwf_t,
+pub fsync_flags: __u32,
+pub poll_events: __u16,
+pub poll32_events: __u32,
+pub sync_range_flags: __u32,
+pub msg_flags: __u32,
+pub timeout_flags: __u32,
+pub accept_flags: __u32,
+pub cancel_flags: __u32,
+pub open_flags: __u32,
+pub statx_flags: __u32,
+pub fadvise_advice: __u32,
+pub splice_flags: __u32,
+pub rename_flags: __u32,
+pub unlink_flags: __u32,
+pub hardlink_flags: __u32,
+pub xattr_flags: __u32,
+pub msg_ring_flags: __u32,
+pub uring_cmd_flags: __u32,
+pub waitid_flags: __u32,
+pub futex_flags: __u32,
+pub install_fd_flags: __u32,
+pub nop_flags: __u32,
+pub pipe_flags: __u32,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_4 {
+pub buf_index: __u16,
+pub buf_group: __u16,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_5 {
+pub splice_fd_in: __s32,
+pub file_index: __u32,
+pub zcrx_ifq_idx: __u32,
+pub optlen: __u32,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_5__bindgen_ty_1,
+pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_5__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_restriction__bindgen_ty_1 {
+pub register_op: __u8,
+pub sqe_op: __u8,
+pub sqe_flags: __u8,
+}
+impl<T> __IncompleteArrayField<T> {
+#[inline]
+pub const fn new() -> Self {
+__IncompleteArrayField(::core::marker::PhantomData, [])
+}
+#[inline]
+pub fn as_ptr(&self) -> *const T {
+self as *const _ as *const T
+}
+#[inline]
+pub fn as_mut_ptr(&mut self) -> *mut T {
+self as *mut _ as *mut T
+}
+#[inline]
+pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+::core::slice::from_raw_parts(self.as_ptr(), len)
+}
+#[inline]
+pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+}
+}
+impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__IncompleteArrayField")
+}
+}
+impl<T> __BindgenUnionField<T> {
+#[inline]
+pub const fn new() -> Self {
+__BindgenUnionField(::core::marker::PhantomData)
+}
+#[inline]
+pub unsafe fn as_ref(&self) -> &T {
+::core::mem::transmute(self)
+}
+#[inline]
+pub unsafe fn as_mut(&mut self) -> &mut T {
+::core::mem::transmute(self)
+}
+}
+impl<T> ::core::default::Default for __BindgenUnionField<T> {
+#[inline]
+fn default() -> Self {
+Self::new()
+}
+}
+impl<T> ::core::clone::Clone for __BindgenUnionField<T> {
+#[inline]
+fn clone(&self) -> Self {
+*self
+}
+}
+impl<T> ::core::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::core::fmt::Debug for __BindgenUnionField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__BindgenUnionField")
+}
+}
+impl<T> ::core::hash::Hash for __BindgenUnionField<T> {
+fn hash<H: ::core::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::core::cmp::PartialEq for __BindgenUnionField<T> {
+fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+true
+}
+}
+impl<T> ::core::cmp::Eq for __BindgenUnionField<T> {}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/ioctl.rs

@@ -0,0 +1,1502 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const FIONREAD: u32 = 21531;
+pub const FIONBIO: u32 = 21537;
+pub const FIOCLEX: u32 = 21585;
+pub const FIONCLEX: u32 = 21584;
+pub const FIOASYNC: u32 = 21586;
+pub const FIOQSIZE: u32 = 21600;
+pub const TCXONC: u32 = 21514;
+pub const TCFLSH: u32 = 21515;
+pub const TIOCSCTTY: u32 = 21518;
+pub const TIOCSPGRP: u32 = 21520;
+pub const TIOCOUTQ: u32 = 21521;
+pub const TIOCSTI: u32 = 21522;
+pub const TIOCSWINSZ: u32 = 21524;
+pub const TIOCMGET: u32 = 21525;
+pub const TIOCMBIS: u32 = 21526;
+pub const TIOCMBIC: u32 = 21527;
+pub const TIOCMSET: u32 = 21528;
+pub const TIOCSSOFTCAR: u32 = 21530;
+pub const TIOCLINUX: u32 = 21532;
+pub const TIOCCONS: u32 = 21533;
+pub const TIOCSSERIAL: u32 = 21535;
+pub const TIOCPKT: u32 = 21536;
+pub const TIOCNOTTY: u32 = 21538;
+pub const TIOCSETD: u32 = 21539;
+pub const TIOCSBRK: u32 = 21543;
+pub const TIOCCBRK: u32 = 21544;
+pub const TIOCSRS485: u32 = 21551;
+pub const TIOCSPTLCK: u32 = 1074025521;
+pub const TIOCSIG: u32 = 1074025526;
+pub const TIOCVHANGUP: u32 = 21559;
+pub const TIOCSERCONFIG: u32 = 21587;
+pub const TIOCSERGWILD: u32 = 21588;
+pub const TIOCSERSWILD: u32 = 21589;
+pub const TIOCSLCKTRMIOS: u32 = 21591;
+pub const TIOCSERGSTRUCT: u32 = 21592;
+pub const TIOCSERGETLSR: u32 = 21593;
+pub const TIOCSERGETMULTI: u32 = 21594;
+pub const TIOCSERSETMULTI: u32 = 21595;
+pub const TIOCMIWAIT: u32 = 21596;
+pub const TCGETS: u32 = 21505;
+pub const TCGETA: u32 = 21509;
+pub const TCSBRK: u32 = 21513;
+pub const TCSBRKP: u32 = 21541;
+pub const TCSETA: u32 = 21510;
+pub const TCSETAF: u32 = 21512;
+pub const TCSETAW: u32 = 21511;
+pub const TIOCEXCL: u32 = 21516;
+pub const TIOCNXCL: u32 = 21517;
+pub const TIOCGDEV: u32 = 2147767346;
+pub const TIOCGEXCL: u32 = 2147767360;
+pub const TIOCGICOUNT: u32 = 21597;
+pub const TIOCGLCKTRMIOS: u32 = 21590;
+pub const TIOCGPGRP: u32 = 21519;
+pub const TIOCGPKT: u32 = 2147767352;
+pub const TIOCGPTLCK: u32 = 2147767353;
+pub const TIOCGPTN: u32 = 2147767344;
+pub const TIOCGPTPEER: u32 = 21569;
+pub const TIOCGRS485: u32 = 21550;
+pub const TIOCGSERIAL: u32 = 21534;
+pub const TIOCGSID: u32 = 21545;
+pub const TIOCGSOFTCAR: u32 = 21529;
+pub const TIOCGWINSZ: u32 = 21523;
+pub const TCGETS2: u32 = 2150388778;
+pub const TCGETX: u32 = 21554;
+pub const TCSETS: u32 = 21506;
+pub const TCSETS2: u32 = 1076646955;
+pub const TCSETSF: u32 = 21508;
+pub const TCSETSF2: u32 = 1076646957;
+pub const TCSETSW: u32 = 21507;
+pub const TCSETSW2: u32 = 1076646956;
+pub const TCSETX: u32 = 21555;
+pub const TCSETXF: u32 = 21556;
+pub const TCSETXW: u32 = 21557;
+pub const TIOCGETD: u32 = 21540;
+pub const MTIOCGET: u32 = 2149346562;
+pub const BLKSSZGET: u32 = 4712;
+pub const BLKPBSZGET: u32 = 4731;
+pub const BLKROSET: u32 = 4701;
+pub const BLKROGET: u32 = 4702;
+pub const BLKRRPART: u32 = 4703;
+pub const BLKGETSIZE: u32 = 4704;
+pub const BLKFLSBUF: u32 = 4705;
+pub const BLKRASET: u32 = 4706;
+pub const BLKRAGET: u32 = 4707;
+pub const BLKFRASET: u32 = 4708;
+pub const BLKFRAGET: u32 = 4709;
+pub const BLKSECTSET: u32 = 4710;
+pub const BLKSECTGET: u32 = 4711;
+pub const BLKPG: u32 = 4713;
+pub const BLKBSZGET: u32 = 2147750512;
+pub const BLKBSZSET: u32 = 1074008689;
+pub const BLKGETSIZE64: u32 = 2147750514;
+pub const BLKTRACESETUP: u32 = 3225424499;
+pub const BLKTRACESTART: u32 = 4724;
+pub const BLKTRACESTOP: u32 = 4725;
+pub const BLKTRACETEARDOWN: u32 = 4726;
+pub const BLKDISCARD: u32 = 4727;
+pub const BLKIOMIN: u32 = 4728;
+pub const BLKIOOPT: u32 = 4729;
+pub const BLKALIGNOFF: u32 = 4730;
+pub const BLKDISCARDZEROES: u32 = 4732;
+pub const BLKSECDISCARD: u32 = 4733;
+pub const BLKROTATIONAL: u32 = 4734;
+pub const BLKZEROOUT: u32 = 4735;
+pub const FIEMAP_MAX_OFFSET: u32 = 4294967295;
+pub const FIEMAP_FLAG_SYNC: u32 = 1;
+pub const FIEMAP_FLAG_XATTR: u32 = 2;
+pub const FIEMAP_FLAG_CACHE: u32 = 4;
+pub const FIEMAP_FLAGS_COMPAT: u32 = 3;
+pub const FIEMAP_EXTENT_LAST: u32 = 1;
+pub const FIEMAP_EXTENT_UNKNOWN: u32 = 2;
+pub const FIEMAP_EXTENT_DELALLOC: u32 = 4;
+pub const FIEMAP_EXTENT_ENCODED: u32 = 8;
+pub const FIEMAP_EXTENT_DATA_ENCRYPTED: u32 = 128;
+pub const FIEMAP_EXTENT_NOT_ALIGNED: u32 = 256;
+pub const FIEMAP_EXTENT_DATA_INLINE: u32 = 512;
+pub const FIEMAP_EXTENT_DATA_TAIL: u32 = 1024;
+pub const FIEMAP_EXTENT_UNWRITTEN: u32 = 2048;
+pub const FIEMAP_EXTENT_MERGED: u32 = 4096;
+pub const FIEMAP_EXTENT_SHARED: u32 = 8192;
+pub const UFFDIO_REGISTER: u32 = 3223366144;
+pub const UFFDIO_UNREGISTER: u32 = 2148575745;
+pub const UFFDIO_WAKE: u32 = 2148575746;
+pub const UFFDIO_COPY: u32 = 3223890435;
+pub const UFFDIO_ZEROPAGE: u32 = 3223366148;
+pub const UFFDIO_WRITEPROTECT: u32 = 3222841862;
+pub const UFFDIO_API: u32 = 3222841919;
+pub const NS_GET_USERNS: u32 = 46849;
+pub const NS_GET_PARENT: u32 = 46850;
+pub const NS_GET_NSTYPE: u32 = 46851;
+pub const KDGETLED: u32 = 19249;
+pub const KDSETLED: u32 = 19250;
+pub const KDGKBLED: u32 = 19300;
+pub const KDSKBLED: u32 = 19301;
+pub const KDGKBTYPE: u32 = 19251;
+pub const KDADDIO: u32 = 19252;
+pub const KDDELIO: u32 = 19253;
+pub const KDENABIO: u32 = 19254;
+pub const KDDISABIO: u32 = 19255;
+pub const KDSETMODE: u32 = 19258;
+pub const KDGETMODE: u32 = 19259;
+pub const KDMKTONE: u32 = 19248;
+pub const KIOCSOUND: u32 = 19247;
+pub const GIO_CMAP: u32 = 19312;
+pub const PIO_CMAP: u32 = 19313;
+pub const GIO_FONT: u32 = 19296;
+pub const GIO_FONTX: u32 = 19307;
+pub const PIO_FONT: u32 = 19297;
+pub const PIO_FONTX: u32 = 19308;
+pub const PIO_FONTRESET: u32 = 19309;
+pub const GIO_SCRNMAP: u32 = 19264;
+pub const GIO_UNISCRNMAP: u32 = 19305;
+pub const PIO_SCRNMAP: u32 = 19265;
+pub const PIO_UNISCRNMAP: u32 = 19306;
+pub const GIO_UNIMAP: u32 = 19302;
+pub const PIO_UNIMAP: u32 = 19303;
+pub const PIO_UNIMAPCLR: u32 = 19304;
+pub const KDGKBMODE: u32 = 19268;
+pub const KDSKBMODE: u32 = 19269;
+pub const KDGKBMETA: u32 = 19298;
+pub const KDSKBMETA: u32 = 19299;
+pub const KDGKBENT: u32 = 19270;
+pub const KDSKBENT: u32 = 19271;
+pub const KDGKBSENT: u32 = 19272;
+pub const KDSKBSENT: u32 = 19273;
+pub const KDGKBDIACR: u32 = 19274;
+pub const KDGETKEYCODE: u32 = 19276;
+pub const KDSETKEYCODE: u32 = 19277;
+pub const KDSIGACCEPT: u32 = 19278;
+pub const VT_OPENQRY: u32 = 22016;
+pub const VT_GETMODE: u32 = 22017;
+pub const VT_SETMODE: u32 = 22018;
+pub const VT_GETSTATE: u32 = 22019;
+pub const VT_RELDISP: u32 = 22021;
+pub const VT_ACTIVATE: u32 = 22022;
+pub const VT_WAITACTIVE: u32 = 22023;
+pub const VT_DISALLOCATE: u32 = 22024;
+pub const VT_RESIZE: u32 = 22025;
+pub const VT_RESIZEX: u32 = 22026;
+pub const FIOSETOWN: u32 = 35073;
+pub const SIOCSPGRP: u32 = 35074;
+pub const FIOGETOWN: u32 = 35075;
+pub const SIOCGPGRP: u32 = 35076;
+pub const SIOCATMARK: u32 = 35077;
+pub const SIOCGSTAMP: u32 = 35078;
+pub const TIOCINQ: u32 = 21531;
+pub const SIOCADDRT: u32 = 35083;
+pub const SIOCDELRT: u32 = 35084;
+pub const SIOCGIFNAME: u32 = 35088;
+pub const SIOCSIFLINK: u32 = 35089;
+pub const SIOCGIFCONF: u32 = 35090;
+pub const SIOCGIFFLAGS: u32 = 35091;
+pub const SIOCSIFFLAGS: u32 = 35092;
+pub const SIOCGIFADDR: u32 = 35093;
+pub const SIOCSIFADDR: u32 = 35094;
+pub const SIOCGIFDSTADDR: u32 = 35095;
+pub const SIOCSIFDSTADDR: u32 = 35096;
+pub const SIOCGIFBRDADDR: u32 = 35097;
+pub const SIOCSIFBRDADDR: u32 = 35098;
+pub const SIOCGIFNETMASK: u32 = 35099;
+pub const SIOCSIFNETMASK: u32 = 35100;
+pub const SIOCGIFMETRIC: u32 = 35101;
+pub const SIOCSIFMETRIC: u32 = 35102;
+pub const SIOCGIFMEM: u32 = 35103;
+pub const SIOCSIFMEM: u32 = 35104;
+pub const SIOCGIFMTU: u32 = 35105;
+pub const SIOCSIFMTU: u32 = 35106;
+pub const SIOCSIFHWADDR: u32 = 35108;
+pub const SIOCGIFENCAP: u32 = 35109;
+pub const SIOCSIFENCAP: u32 = 35110;
+pub const SIOCGIFHWADDR: u32 = 35111;
+pub const SIOCGIFSLAVE: u32 = 35113;
+pub const SIOCSIFSLAVE: u32 = 35120;
+pub const SIOCADDMULTI: u32 = 35121;
+pub const SIOCDELMULTI: u32 = 35122;
+pub const SIOCDARP: u32 = 35155;
+pub const SIOCGARP: u32 = 35156;
+pub const SIOCSARP: u32 = 35157;
+pub const SIOCDRARP: u32 = 35168;
+pub const SIOCGRARP: u32 = 35169;
+pub const SIOCSRARP: u32 = 35170;
+pub const SIOCGIFMAP: u32 = 35184;
+pub const SIOCSIFMAP: u32 = 35185;
+pub const SIOCRTMSG: u32 = 35085;
+pub const SIOCSIFNAME: u32 = 35107;
+pub const SIOCGIFINDEX: u32 = 35123;
+pub const SIOGIFINDEX: u32 = 35123;
+pub const SIOCSIFPFLAGS: u32 = 35124;
+pub const SIOCGIFPFLAGS: u32 = 35125;
+pub const SIOCDIFADDR: u32 = 35126;
+pub const SIOCSIFHWBROADCAST: u32 = 35127;
+pub const SIOCGIFCOUNT: u32 = 35128;
+pub const SIOCGIFBR: u32 = 35136;
+pub const SIOCSIFBR: u32 = 35137;
+pub const SIOCGIFTXQLEN: u32 = 35138;
+pub const SIOCSIFTXQLEN: u32 = 35139;
+pub const SIOCADDDLCI: u32 = 35200;
+pub const SIOCDELDLCI: u32 = 35201;
+pub const SIOCDEVPRIVATE: u32 = 35312;
+pub const SIOCPROTOPRIVATE: u32 = 35296;
+pub const FIBMAP: u32 = 1;
+pub const FIGETBSZ: u32 = 2;
+pub const FIFREEZE: u32 = 3221510263;
+pub const FITHAW: u32 = 3221510264;
+pub const FITRIM: u32 = 3222820985;
+pub const FICLONE: u32 = 1074041865;
+pub const FICLONERANGE: u32 = 1075876877;
+pub const FIDEDUPERANGE: u32 = 3222836278;
+pub const FS_IOC_GETFLAGS: u32 = 2147771905;
+pub const FS_IOC_SETFLAGS: u32 = 1074030082;
+pub const FS_IOC_GETVERSION: u32 = 2147776001;
+pub const FS_IOC_SETVERSION: u32 = 1074034178;
+pub const FS_IOC_FIEMAP: u32 = 3223348747;
+pub const FS_IOC32_GETFLAGS: u32 = 2147771905;
+pub const FS_IOC32_SETFLAGS: u32 = 1074030082;
+pub const FS_IOC32_GETVERSION: u32 = 2147776001;
+pub const FS_IOC32_SETVERSION: u32 = 1074034178;
+pub const FS_IOC_FSGETXATTR: u32 = 2149341215;
+pub const FS_IOC_FSSETXATTR: u32 = 1075599392;
+pub const FS_IOC_GETFSLABEL: u32 = 2164298801;
+pub const FS_IOC_SETFSLABEL: u32 = 1090556978;
+pub const EXT4_IOC_GETVERSION: u32 = 2147771907;
+pub const EXT4_IOC_SETVERSION: u32 = 1074030084;
+pub const EXT4_IOC_GETVERSION_OLD: u32 = 2147776001;
+pub const EXT4_IOC_SETVERSION_OLD: u32 = 1074034178;
+pub const EXT4_IOC_GETRSVSZ: u32 = 2147771909;
+pub const EXT4_IOC_SETRSVSZ: u32 = 1074030086;
+pub const EXT4_IOC_GROUP_EXTEND: u32 = 1074030087;
+pub const EXT4_IOC_MIGRATE: u32 = 26121;
+pub const EXT4_IOC_ALLOC_DA_BLKS: u32 = 26124;
+pub const EXT4_IOC_RESIZE_FS: u32 = 1074292240;
+pub const EXT4_IOC_SWAP_BOOT: u32 = 26129;
+pub const EXT4_IOC_PRECACHE_EXTENTS: u32 = 26130;
+pub const EXT4_IOC_CLEAR_ES_CACHE: u32 = 26152;
+pub const EXT4_IOC_GETSTATE: u32 = 1074030121;
+pub const EXT4_IOC_GET_ES_CACHE: u32 = 3223348778;
+pub const EXT4_IOC_CHECKPOINT: u32 = 1074030123;
+pub const EXT4_IOC_SHUTDOWN: u32 = 2147768445;
+pub const EXT4_IOC32_GETVERSION: u32 = 2147771907;
+pub const EXT4_IOC32_SETVERSION: u32 = 1074030084;
+pub const EXT4_IOC32_GETRSVSZ: u32 = 2147771909;
+pub const EXT4_IOC32_SETRSVSZ: u32 = 1074030086;
+pub const EXT4_IOC32_GROUP_EXTEND: u32 = 1074030087;
+pub const EXT4_IOC32_GETVERSION_OLD: u32 = 2147776001;
+pub const EXT4_IOC32_SETVERSION_OLD: u32 = 1074034178;
+pub const VIDIOC_SUBDEV_QUERYSTD: u32 = 2148030015;
+pub const AUTOFS_DEV_IOCTL_CLOSEMOUNT: u32 = 3222836085;
+pub const LIRC_SET_SEND_CARRIER: u32 = 1074030867;
+pub const AUTOFS_IOC_PROTOSUBVER: u32 = 2147783527;
+pub const PTP_SYS_OFFSET_PRECISE: u32 = 3225435400;
+pub const FSI_SCOM_WRITE: u32 = 3223352066;
+pub const ATM_GETCIRANGE: u32 = 1074553226;
+pub const DMA_BUF_SET_NAME_B: u32 = 1074291201;
+pub const RIO_CM_EP_GET_LIST_SIZE: u32 = 3221512961;
+pub const TUNSETPERSIST: u32 = 1074025675;
+pub const FS_IOC_GET_ENCRYPTION_POLICY: u32 = 1074554389;
+pub const CEC_RECEIVE: u32 = 3224920326;
+pub const MGSL_IOCGPARAMS: u32 = 2149608705;
+pub const ENI_SETMULT: u32 = 1074553191;
+pub const RIO_GET_EVENT_MASK: u32 = 2147773710;
+pub const LIRC_GET_MAX_TIMEOUT: u32 = 2147772681;
+pub const USBDEVFS_CLAIMINTERFACE: u32 = 2147767567;
+pub const CHIOMOVE: u32 = 1075077889;
+pub const SONYPI_IOCGBATFLAGS: u32 = 2147579399;
+pub const BTRFS_IOC_SYNC: u32 = 37896;
+pub const VIDIOC_TRY_FMT: u32 = 3234616896;
+pub const LIRC_SET_REC_MODE: u32 = 1074030866;
+pub const VIDIOC_DQEVENT: u32 = 2155370073;
+pub const RPMSG_DESTROY_EPT_IOCTL: u32 = 46338;
+pub const UVCIOC_CTRL_MAP: u32 = 3227022624;
+pub const VHOST_SET_BACKEND_FEATURES: u32 = 1074310949;
+pub const VHOST_VSOCK_SET_GUEST_CID: u32 = 1074311008;
+pub const UI_SET_KEYBIT: u32 = 1074025829;
+pub const LIRC_SET_REC_TIMEOUT: u32 = 1074030872;
+pub const FS_IOC_GET_ENCRYPTION_KEY_STATUS: u32 = 3229640218;
+pub const BTRFS_IOC_TREE_SEARCH_V2: u32 = 3228603409;
+pub const VHOST_SET_VRING_BASE: u32 = 1074310930;
+pub const RIO_ENABLE_DOORBELL_RANGE: u32 = 1074294025;
+pub const VIDIOC_TRY_EXT_CTRLS: u32 = 3222820425;
+pub const LIRC_GET_REC_MODE: u32 = 2147772674;
+pub const PPGETTIME: u32 = 2148036757;
+pub const BTRFS_IOC_RM_DEV: u32 = 1342215179;
+pub const ATM_SETBACKEND: u32 = 1073897970;
+pub const FSL_HV_IOCTL_PARTITION_START: u32 = 3222318851;
+pub const FBIO_WAITEVENT: u32 = 18056;
+pub const SWITCHTEC_IOCTL_PORT_TO_PFF: u32 = 3222034245;
+pub const NVME_IOCTL_IO_CMD: u32 = 3225964099;
+pub const IPMICTL_RECEIVE_MSG_TRUNC: u32 = 3222825227;
+pub const FDTWADDLE: u32 = 601;
+pub const NVME_IOCTL_SUBMIT_IO: u32 = 1076645442;
+pub const NILFS_IOCTL_SYNC: u32 = 2148036234;
+pub const VIDIOC_SUBDEV_S_DV_TIMINGS: u32 = 3229898327;
+pub const ASPEED_LPC_CTRL_IOCTL_GET_SIZE: u32 = 3222319616;
+pub const DM_DEV_STATUS: u32 = 3241737479;
+pub const TEE_IOC_CLOSE_SESSION: u32 = 2147787781;
+pub const NS_GETPSTAT: u32 = 3222036833;
+pub const UI_SET_PROPBIT: u32 = 1074025838;
+pub const TUNSETFILTEREBPF: u32 = 2147767521;
+pub const RIO_MPORT_MAINT_COMPTAG_SET: u32 = 1074031874;
+pub const AUTOFS_DEV_IOCTL_VERSION: u32 = 3222836081;
+pub const WDIOC_SETOPTIONS: u32 = 2147768068;
+pub const VHOST_SCSI_SET_ENDPOINT: u32 = 1088991040;
+pub const MGSL_IOCGTXIDLE: u32 = 27907;
+pub const ATM_ADDLECSADDR: u32 = 1074553230;
+pub const FSL_HV_IOCTL_GETPROP: u32 = 3223891719;
+pub const FDGETPRM: u32 = 2149319172;
+pub const HIDIOCAPPLICATION: u32 = 18434;
+pub const ENI_MEMDUMP: u32 = 1074553184;
+pub const PTP_SYS_OFFSET2: u32 = 1128283406;
+pub const VIDIOC_SUBDEV_G_DV_TIMINGS: u32 = 3229898328;
+pub const DMA_BUF_SET_NAME_A: u32 = 1074029057;
+pub const PTP_PIN_GETFUNC: u32 = 3227532550;
+pub const PTP_SYS_OFFSET_EXTENDED: u32 = 3300932873;
+pub const DFL_FPGA_PORT_UINT_SET_IRQ: u32 = 1074312776;
+pub const RTC_EPOCH_READ: u32 = 2147774477;
+pub const VIDIOC_SUBDEV_S_SELECTION: u32 = 3225441854;
+pub const VIDIOC_QUERY_EXT_CTRL: u32 = 3236451943;
+pub const ATM_GETLECSADDR: u32 = 1074553232;
+pub const FSL_HV_IOCTL_PARTITION_STOP: u32 = 3221794564;
+pub const SONET_GETDIAG: u32 = 2147770644;
+pub const ATMMPC_DATA: u32 = 25049;
+pub const IPMICTL_UNREGISTER_FOR_CMD_CHANS: u32 = 2148296989;
+pub const HIDIOCGCOLLECTIONINDEX: u32 = 1075333136;
+pub const RPMSG_CREATE_EPT_IOCTL: u32 = 1076409601;
+pub const GPIOHANDLE_GET_LINE_VALUES_IOCTL: u32 = 3225465864;
+pub const UI_DEV_SETUP: u32 = 1079792899;
+pub const ISST_IF_IO_CMD: u32 = 1074068994;
+pub const RIO_MPORT_MAINT_READ_REMOTE: u32 = 2149084423;
+pub const VIDIOC_OMAP3ISP_HIST_CFG: u32 = 3224393412;
+pub const BLKGETNRZONES: u32 = 2147750533;
+pub const VIDIOC_G_MODULATOR: u32 = 3225703990;
+pub const VBG_IOCTL_WRITE_CORE_DUMP: u32 = 3223082515;
+pub const USBDEVFS_SETINTERFACE: u32 = 2148029700;
+pub const PPPIOCGCHAN: u32 = 2147775543;
+pub const EVIOCGVERSION: u32 = 2147763457;
+pub const VHOST_NET_SET_BACKEND: u32 = 1074310960;
+pub const USBDEVFS_REAPURBNDELAY: u32 = 1074025741;
+pub const RNDZAPENTCNT: u32 = 20996;
+pub const VIDIOC_G_PARM: u32 = 3234616853;
+pub const TUNGETDEVNETNS: u32 = 21731;
+pub const LIRC_SET_MEASURE_CARRIER_MODE: u32 = 1074030877;
+pub const VHOST_SET_VRING_ERR: u32 = 1074310946;
+pub const VDUSE_VQ_SETUP: u32 = 1075872020;
+pub const AUTOFS_IOC_SETTIMEOUT: u32 = 3221525348;
+pub const VIDIOC_S_FREQUENCY: u32 = 1076647481;
+pub const F2FS_IOC_SEC_TRIM_FILE: u32 = 1075377428;
+pub const FS_IOC_REMOVE_ENCRYPTION_KEY: u32 = 3225445912;
+pub const WDIOC_GETPRETIMEOUT: u32 = 2147768073;
+pub const USBDEVFS_DROP_PRIVILEGES: u32 = 1074025758;
+pub const BTRFS_IOC_SNAP_CREATE_V2: u32 = 1342215191;
+pub const VHOST_VSOCK_SET_RUNNING: u32 = 1074048865;
+pub const STP_SET_OPTIONS: u32 = 1074275586;
+pub const FBIO_RADEON_GET_MIRROR: u32 = 2147762179;
+pub const IVTVFB_IOC_DMA_FRAME: u32 = 1074550464;
+pub const IPMICTL_SEND_COMMAND: u32 = 2148821261;
+pub const VIDIOC_G_ENC_INDEX: u32 = 2283296332;
+pub const DFL_FPGA_FME_PORT_PR: u32 = 46720;
+pub const CHIOSVOLTAG: u32 = 1076912914;
+pub const ATM_SETESIF: u32 = 1074553229;
+pub const FW_CDEV_IOC_SEND_RESPONSE: u32 = 1075061508;
+pub const PMU_IOC_GET_MODEL: u32 = 2147762691;
+pub const JSIOCGBTNMAP: u32 = 2214619700;
+pub const USBDEVFS_HUB_PORTINFO: u32 = 2155894035;
+pub const VBG_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS: u32 = 3222820363;
+pub const FDCLRPRM: u32 = 577;
+pub const BTRFS_IOC_SCRUB: u32 = 3288372251;
+pub const USBDEVFS_DISCONNECT: u32 = 21782;
+pub const TUNSETVNETBE: u32 = 1074025694;
+pub const ATMTCP_REMOVE: u32 = 24975;
+pub const VHOST_VDPA_GET_CONFIG: u32 = 2148052851;
+pub const PPPIOCGNPMODE: u32 = 3221779532;
+pub const FDGETDRVPRM: u32 = 2153251345;
+pub const TUNSETVNETLE: u32 = 1074025692;
+pub const PHN_SETREG: u32 = 1074294790;
+pub const PPPIOCDETACH: u32 = 1074033724;
+pub const MMTIMER_GETRES: u32 = 2147773697;
+pub const VIDIOC_SUBDEV_ENUMSTD: u32 = 3225441817;
+pub const PPGETFLAGS: u32 = 2147774618;
+pub const VDUSE_DEV_GET_FEATURES: u32 = 2148040977;
+pub const CAPI_MANUFACTURER_CMD: u32 = 3221766944;
+pub const VIDIOC_G_TUNER: u32 = 3226752541;
+pub const DM_TABLE_STATUS: u32 = 3241737484;
+pub const DM_DEV_ARM_POLL: u32 = 3241737488;
+pub const NE_CREATE_VM: u32 = 2148052512;
+pub const MEDIA_IOC_ENUM_LINKS: u32 = 3223092226;
+pub const F2FS_IOC_PRECACHE_EXTENTS: u32 = 62735;
+pub const DFL_FPGA_PORT_DMA_MAP: u32 = 46659;
+pub const MGSL_IOCGXCTRL: u32 = 27926;
+pub const FW_CDEV_IOC_SEND_REQUEST: u32 = 1076110081;
+pub const SONYPI_IOCGBLUE: u32 = 2147579400;
+pub const F2FS_IOC_DECOMPRESS_FILE: u32 = 62743;
+pub const I2OHTML: u32 = 3223087369;
+pub const VFIO_GET_API_VERSION: u32 = 15204;
+pub const IDT77105_GETSTATZ: u32 = 1074553139;
+pub const I2OPARMSET: u32 = 3222825219;
+pub const TEE_IOC_CANCEL: u32 = 2148049924;
+pub const PTP_SYS_OFFSET_PRECISE2: u32 = 3225435409;
+pub const DFL_FPGA_PORT_RESET: u32 = 46656;
+pub const PPPIOCGASYNCMAP: u32 = 2147775576;
+pub const EVIOCGKEYCODE_V2: u32 = 2150122756;
+pub const DM_DEV_SET_GEOMETRY: u32 = 3241737487;
+pub const HIDIOCSUSAGE: u32 = 1075333132;
+pub const FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE_ONCE: u32 = 1075323664;
+pub const PTP_EXTTS_REQUEST: u32 = 1074806018;
+pub const SWITCHTEC_IOCTL_EVENT_CTL: u32 = 3223869251;
+pub const WDIOC_SETPRETIMEOUT: u32 = 3221509896;
+pub const VHOST_SCSI_CLEAR_ENDPOINT: u32 = 1088991041;
+pub const JSIOCGAXES: u32 = 2147576337;
+pub const HIDIOCSFLAG: u32 = 1074022415;
+pub const PTP_PEROUT_REQUEST2: u32 = 1077427468;
+pub const PPWDATA: u32 = 1073836166;
+pub const PTP_CLOCK_GETCAPS: u32 = 2152742145;
+pub const FDGETMAXERRS: u32 = 2148794894;
+pub const TUNSETQUEUE: u32 = 1074025689;
+pub const PTP_ENABLE_PPS: u32 = 1074019588;
+pub const SIOCSIFATMTCP: u32 = 24960;
+pub const CEC_ADAP_G_LOG_ADDRS: u32 = 2153537795;
+pub const ND_IOCTL_ARS_CAP: u32 = 3223342593;
+pub const NBD_SET_BLKSIZE: u32 = 43777;
+pub const NBD_SET_TIMEOUT: u32 = 43785;
+pub const VHOST_SCSI_GET_ABI_VERSION: u32 = 1074048834;
+pub const RIO_UNMAP_INBOUND: u32 = 1074294034;
+pub const ATM_QUERYLOOP: u32 = 1074553172;
+pub const DFL_FPGA_GET_API_VERSION: u32 = 46592;
+pub const USBDEVFS_WAIT_FOR_RESUME: u32 = 21795;
+pub const FBIO_CURSOR: u32 = 3225961992;
+pub const RNDCLEARPOOL: u32 = 20998;
+pub const VIDIOC_QUERYSTD: u32 = 2148030015;
+pub const DMA_BUF_IOCTL_SYNC: u32 = 1074291200;
+pub const SCIF_RECV: u32 = 3222565639;
+pub const PTP_PIN_GETFUNC2: u32 = 3227532559;
+pub const FW_CDEV_IOC_ALLOCATE: u32 = 3223331586;
+pub const CEC_ADAP_G_CAPS: u32 = 3226231040;
+pub const VIDIOC_G_FBUF: u32 = 2150389258;
+pub const PTP_ENABLE_PPS2: u32 = 1074019597;
+pub const PCITEST_CLEAR_IRQ: u32 = 20496;
+pub const IPMICTL_SET_GETS_EVENTS_CMD: u32 = 2147772688;
+pub const BTRFS_IOC_DEVICES_READY: u32 = 2415957031;
+pub const JSIOCGAXMAP: u32 = 2151705138;
+pub const FW_CDEV_IOC_GET_CYCLE_TIMER: u32 = 2148279052;
+pub const FW_CDEV_IOC_SET_ISO_CHANNELS: u32 = 1074537239;
+pub const RTC_WIE_OFF: u32 = 28688;
+pub const PPGETMODE: u32 = 2147774616;
+pub const VIDIOC_DBG_G_REGISTER: u32 = 3224917584;
+pub const PTP_SYS_OFFSET: u32 = 1128283397;
+pub const BTRFS_IOC_SPACE_INFO: u32 = 3222311956;
+pub const VIDIOC_SUBDEV_ENUM_FRAME_SIZE: u32 = 3225441866;
+pub const ND_IOCTL_VENDOR: u32 = 3221769737;
+pub const SCIF_VREADFROM: u32 = 3223614220;
+pub const BTRFS_IOC_TRANS_START: u32 = 37894;
+pub const INOTIFY_IOC_SETNEXTWD: u32 = 1074022656;
+pub const SNAPSHOT_GET_IMAGE_SIZE: u32 = 2148021006;
+pub const TUNDETACHFILTER: u32 = 1074287830;
+pub const ND_IOCTL_CLEAR_ERROR: u32 = 3223342596;
+pub const IOC_PR_CLEAR: u32 = 1074819277;
+pub const SCIF_READFROM: u32 = 3223614218;
+pub const PPPIOCGDEBUG: u32 = 2147775553;
+pub const BLKGETZONESZ: u32 = 2147750532;
+pub const HIDIOCGUSAGES: u32 = 3491514387;
+pub const SONYPI_IOCGTEMP: u32 = 2147579404;
+pub const UI_SET_MSCBIT: u32 = 1074025832;
+pub const APM_IOC_SUSPEND: u32 = 16642;
+pub const BTRFS_IOC_TREE_SEARCH: u32 = 3489698833;
+pub const RTC_PLL_GET: u32 = 2149347345;
+pub const RIO_CM_EP_GET_LIST: u32 = 3221512962;
+pub const USBDEVFS_DISCSIGNAL: u32 = 2148029710;
+pub const LIRC_GET_MIN_TIMEOUT: u32 = 2147772680;
+pub const SWITCHTEC_IOCTL_EVENT_SUMMARY_LEGACY: u32 = 2174244674;
+pub const DM_TARGET_MSG: u32 = 3241737486;
+pub const SONYPI_IOCGBAT1REM: u32 = 2147644931;
+pub const EVIOCSFF: u32 = 1076643200;
+pub const TUNSETGROUP: u32 = 1074025678;
+pub const EVIOCGKEYCODE: u32 = 2148025604;
+pub const KCOV_REMOTE_ENABLE: u32 = 1075340134;
+pub const ND_IOCTL_GET_CONFIG_SIZE: u32 = 3222031876;
+pub const FDEJECT: u32 = 602;
+pub const TUNSETOFFLOAD: u32 = 1074025680;
+pub const PPPIOCCONNECT: u32 = 1074033722;
+pub const ATM_ADDADDR: u32 = 1074553224;
+pub const VDUSE_DEV_INJECT_CONFIG_IRQ: u32 = 33043;
+pub const AUTOFS_DEV_IOCTL_ASKUMOUNT: u32 = 3222836093;
+pub const VHOST_VDPA_GET_STATUS: u32 = 2147594097;
+pub const CCISS_PASSTHRU: u32 = 3226747403;
+pub const MGSL_IOCCLRMODCOUNT: u32 = 27919;
+pub const TEE_IOC_SUPPL_SEND: u32 = 2148574215;
+pub const ATMARPD_CTRL: u32 = 25057;
+pub const UI_ABS_SETUP: u32 = 1075598596;
+pub const UI_DEV_DESTROY: u32 = 21762;
+pub const BTRFS_IOC_QUOTA_CTL: u32 = 3222311976;
+pub const RTC_AIE_ON: u32 = 28673;
+pub const AUTOFS_IOC_EXPIRE: u32 = 2165085029;
+pub const PPPIOCSDEBUG: u32 = 1074033728;
+pub const GPIO_V2_LINE_SET_VALUES_IOCTL: u32 = 3222320143;
+pub const PPPIOCSMRU: u32 = 1074033746;
+pub const CCISS_DEREGDISK: u32 = 16908;
+pub const UI_DEV_CREATE: u32 = 21761;
+pub const FUSE_DEV_IOC_CLONE: u32 = 2147804416;
+pub const BTRFS_IOC_START_SYNC: u32 = 2148045848;
+pub const NILFS_IOCTL_DELETE_CHECKPOINT: u32 = 1074294401;
+pub const SNAPSHOT_AVAIL_SWAP_SIZE: u32 = 2148021011;
+pub const DM_TABLE_CLEAR: u32 = 3241737482;
+pub const CCISS_GETINTINFO: u32 = 2148024834;
+pub const PPPIOCSASYNCMAP: u32 = 1074033751;
+pub const I2OEVTGET: u32 = 2154326283;
+pub const NVME_IOCTL_RESET: u32 = 20036;
+pub const PPYIELD: u32 = 28813;
+pub const NVME_IOCTL_IO64_CMD: u32 = 3226488392;
+pub const TUNSETCARRIER: u32 = 1074025698;
+pub const DM_DEV_WAIT: u32 = 3241737480;
+pub const RTC_WIE_ON: u32 = 28687;
+pub const MEDIA_IOC_DEVICE_INFO: u32 = 3238034432;
+pub const RIO_CM_CHAN_CREATE: u32 = 3221381891;
+pub const MGSL_IOCSPARAMS: u32 = 1075866880;
+pub const RTC_SET_TIME: u32 = 1076129802;
+pub const VHOST_RESET_OWNER: u32 = 44802;
+pub const IOC_OPAL_PSID_REVERT_TPR: u32 = 1091072232;
+pub const AUTOFS_DEV_IOCTL_OPENMOUNT: u32 = 3222836084;
+pub const UDF_GETEABLOCK: u32 = 2147773505;
+pub const VFIO_IOMMU_MAP_DMA: u32 = 15217;
+pub const VIDIOC_SUBSCRIBE_EVENT: u32 = 1075861082;
+pub const HIDIOCGFLAG: u32 = 2147764238;
+pub const HIDIOCGUCODE: u32 = 3222816781;
+pub const VIDIOC_OMAP3ISP_AF_CFG: u32 = 3226228421;
+pub const DM_REMOVE_ALL: u32 = 3241737473;
+pub const ASPEED_LPC_CTRL_IOCTL_MAP: u32 = 1074835969;
+pub const CCISS_GETFIRMVER: u32 = 2147762696;
+pub const ND_IOCTL_ARS_START: u32 = 3223342594;
+pub const PPPIOCSMRRU: u32 = 1074033723;
+pub const CEC_ADAP_S_LOG_ADDRS: u32 = 3227279620;
+pub const RPROC_GET_SHUTDOWN_ON_RELEASE: u32 = 2147792642;
+pub const DMA_HEAP_IOCTL_ALLOC: u32 = 3222816768;
+pub const PPSETTIME: u32 = 1074294934;
+pub const RTC_ALM_READ: u32 = 2149871624;
+pub const VDUSE_SET_API_VERSION: u32 = 1074299137;
+pub const RIO_MPORT_MAINT_WRITE_REMOTE: u32 = 1075342600;
+pub const VIDIOC_SUBDEV_S_CROP: u32 = 3224917564;
+pub const USBDEVFS_CONNECT: u32 = 21783;
+pub const SYNC_IOC_FILE_INFO: u32 = 3224911364;
+pub const ATMARP_MKIP: u32 = 25058;
+pub const VFIO_IOMMU_SPAPR_TCE_GET_INFO: u32 = 15216;
+pub const CCISS_GETHEARTBEAT: u32 = 2147762694;
+pub const ATM_RSTADDR: u32 = 1074553223;
+pub const NBD_SET_SIZE: u32 = 43778;
+pub const UDF_GETVOLIDENT: u32 = 2147773506;
+pub const GPIO_V2_LINE_GET_VALUES_IOCTL: u32 = 3222320142;
+pub const MGSL_IOCSTXIDLE: u32 = 27906;
+pub const FSL_HV_IOCTL_SETPROP: u32 = 3223891720;
+pub const BTRFS_IOC_GET_DEV_STATS: u32 = 3288896564;
+pub const PPRSTATUS: u32 = 2147577985;
+pub const MGSL_IOCTXENABLE: u32 = 27908;
+pub const UDF_GETEASIZE: u32 = 2147773504;
+pub const NVME_IOCTL_ADMIN64_CMD: u32 = 3226488391;
+pub const VHOST_SET_OWNER: u32 = 44801;
+pub const RIO_ALLOC_DMA: u32 = 3222826259;
+pub const RIO_CM_CHAN_ACCEPT: u32 = 3221775111;
+pub const I2OHRTGET: u32 = 3222038785;
+pub const ATM_SETCIRANGE: u32 = 1074553227;
+pub const HPET_IE_ON: u32 = 26625;
+pub const PERF_EVENT_IOC_ID: u32 = 2147755015;
+pub const TUNSETSNDBUF: u32 = 1074025684;
+pub const PTP_PIN_SETFUNC: u32 = 1080048903;
+pub const PPPIOCDISCONN: u32 = 29753;
+pub const VIDIOC_QUERYCTRL: u32 = 3225703972;
+pub const PPEXCL: u32 = 28815;
+pub const PCITEST_MSI: u32 = 1074024451;
+pub const FDWERRORCLR: u32 = 598;
+pub const AUTOFS_IOC_FAIL: u32 = 37729;
+pub const USBDEVFS_IOCTL: u32 = 3222033682;
+pub const VIDIOC_S_STD: u32 = 1074288152;
+pub const F2FS_IOC_RESIZE_FS: u32 = 1074328848;
+pub const SONET_SETDIAG: u32 = 3221512466;
+pub const BTRFS_IOC_DEFRAG: u32 = 1342215170;
+pub const CCISS_GETDRIVVER: u32 = 2147762697;
+pub const IPMICTL_GET_TIMING_PARMS_CMD: u32 = 2148034839;
+pub const HPET_IRQFREQ: u32 = 1074030598;
+pub const ATM_GETESI: u32 = 1074553221;
+pub const CCISS_GETLUNINFO: u32 = 2148286993;
+pub const AUTOFS_DEV_IOCTL_ISMOUNTPOINT: u32 = 3222836094;
+pub const TEE_IOC_SHM_ALLOC: u32 = 3222316033;
+pub const PERF_EVENT_IOC_SET_BPF: u32 = 1074013192;
+pub const UDMABUF_CREATE_LIST: u32 = 1074296131;
+pub const VHOST_SET_LOG_BASE: u32 = 1074310916;
+pub const ZATM_GETPOOL: u32 = 1074553185;
+pub const BR2684_SETFILT: u32 = 1075601808;
+pub const RNDGETPOOL: u32 = 2148028930;
+pub const PPS_GETPARAMS: u32 = 2147774625;
+pub const IOC_PR_RESERVE: u32 = 1074819273;
+pub const VIDIOC_TRY_DECODER_CMD: u32 = 3225966177;
+pub const RIO_CM_CHAN_CLOSE: u32 = 1073898244;
+pub const VIDIOC_DV_TIMINGS_CAP: u32 = 3230684772;
+pub const IOCTL_MEI_CONNECT_CLIENT_VTAG: u32 = 3222554628;
+pub const PMU_IOC_GET_BACKLIGHT: u32 = 2147762689;
+pub const USBDEVFS_GET_CAPABILITIES: u32 = 2147767578;
+pub const SCIF_WRITETO: u32 = 3223614219;
+pub const UDF_RELOCATE_BLOCKS: u32 = 3221515331;
+pub const FSL_HV_IOCTL_PARTITION_RESTART: u32 = 3221794561;
+pub const CCISS_REGNEWD: u32 = 16910;
+pub const FAT_IOCTL_SET_ATTRIBUTES: u32 = 1074033169;
+pub const VIDIOC_CREATE_BUFS: u32 = 3237500508;
+pub const CAPI_GET_VERSION: u32 = 3222291207;
+pub const SWITCHTEC_IOCTL_EVENT_SUMMARY: u32 = 2228508482;
+pub const VFIO_EEH_PE_OP: u32 = 15225;
+pub const FW_CDEV_IOC_CREATE_ISO_CONTEXT: u32 = 3223069448;
+pub const F2FS_IOC_RELEASE_COMPRESS_BLOCKS: u32 = 2148070674;
+pub const NBD_SET_SIZE_BLOCKS: u32 = 43783;
+pub const IPMI_BMC_IOCTL_SET_SMS_ATN: u32 = 45312;
+pub const ASPEED_P2A_CTRL_IOCTL_GET_MEMORY_CONFIG: u32 = 3222319873;
+pub const VIDIOC_S_AUDOUT: u32 = 1077171762;
+pub const VIDIOC_S_FMT: u32 = 3234616837;
+pub const PPPIOCATTACH: u32 = 1074033725;
+pub const VHOST_GET_VRING_BUSYLOOP_TIMEOUT: u32 = 1074310948;
+pub const FS_IOC_MEASURE_VERITY: u32 = 3221513862;
+pub const CCISS_BIG_PASSTHRU: u32 = 3227009554;
+pub const IPMICTL_SET_MY_LUN_CMD: u32 = 2147772691;
+pub const PCITEST_LEGACY_IRQ: u32 = 20482;
+pub const USBDEVFS_SUBMITURB: u32 = 2150389002;
+pub const AUTOFS_IOC_READY: u32 = 37728;
+pub const BTRFS_IOC_SEND: u32 = 1078236198;
+pub const VIDIOC_G_EXT_CTRLS: u32 = 3222820423;
+pub const JSIOCSBTNMAP: u32 = 1140877875;
+pub const PPPIOCSFLAGS: u32 = 1074033753;
+pub const NVRAM_INIT: u32 = 28736;
+pub const RFKILL_IOCTL_NOINPUT: u32 = 20993;
+pub const BTRFS_IOC_BALANCE: u32 = 1342215180;
+pub const FS_IOC_GETFSMAP: u32 = 3233830971;
+pub const IPMICTL_GET_MY_CHANNEL_LUN_CMD: u32 = 2147772699;
+pub const STP_POLICY_ID_GET: u32 = 2148541697;
+pub const PPSETFLAGS: u32 = 1074032795;
+pub const CEC_ADAP_S_PHYS_ADDR: u32 = 1073897730;
+pub const ATMTCP_CREATE: u32 = 24974;
+pub const IPMI_BMC_IOCTL_FORCE_ABORT: u32 = 45314;
+pub const PPPIOCGXASYNCMAP: u32 = 2149610576;
+pub const VHOST_SET_VRING_CALL: u32 = 1074310945;
+pub const LIRC_GET_FEATURES: u32 = 2147772672;
+pub const GSMIOC_DISABLE_NET: u32 = 18179;
+pub const AUTOFS_IOC_CATATONIC: u32 = 37730;
+pub const NBD_DO_IT: u32 = 43779;
+pub const LIRC_SET_REC_CARRIER_RANGE: u32 = 1074030879;
+pub const IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD: u32 = 2147772697;
+pub const EVIOCSCLOCKID: u32 = 1074021792;
+pub const USBDEVFS_FREE_STREAMS: u32 = 2148029725;
+pub const FSI_SCOM_RESET: u32 = 1074033411;
+pub const PMU_IOC_GRAB_BACKLIGHT: u32 = 2147762694;
+pub const VIDIOC_SUBDEV_S_FMT: u32 = 3227014661;
+pub const FDDEFPRM: u32 = 1075577411;
+pub const TEE_IOC_INVOKE: u32 = 2148574211;
+pub const USBDEVFS_BULK: u32 = 3222295810;
+pub const SCIF_VWRITETO: u32 = 3223614221;
+pub const SONYPI_IOCSBRT: u32 = 1073837568;
+pub const BTRFS_IOC_FILE_EXTENT_SAME: u32 = 3222836278;
+pub const RTC_PIE_ON: u32 = 28677;
+pub const BTRFS_IOC_SCAN_DEV: u32 = 1342215172;
+pub const PPPIOCXFERUNIT: u32 = 29774;
+pub const WDIOC_GETTIMEOUT: u32 = 2147768071;
+pub const BTRFS_IOC_SET_RECEIVED_SUBVOL: u32 = 3233846309;
+pub const DFL_FPGA_PORT_ERR_SET_IRQ: u32 = 1074312774;
+pub const FBIO_WAITFORVSYNC: u32 = 1074021920;
+pub const RTC_PIE_OFF: u32 = 28678;
+pub const EVIOCGRAB: u32 = 1074021776;
+pub const PMU_IOC_SET_BACKLIGHT: u32 = 1074020866;
+pub const EVIOCGREP: u32 = 2148025603;
+pub const PERF_EVENT_IOC_MODIFY_ATTRIBUTES: u32 = 1074013195;
+pub const UFFDIO_CONTINUE: u32 = 3223366151;
+pub const VDUSE_GET_API_VERSION: u32 = 2148040960;
+pub const RTC_RD_TIME: u32 = 2149871625;
+pub const FDMSGOFF: u32 = 582;
+pub const IPMICTL_REGISTER_FOR_CMD_CHANS: u32 = 2148296988;
+pub const CAPI_GET_ERRCODE: u32 = 2147631905;
+pub const PCITEST_SET_IRQTYPE: u32 = 1074024456;
+pub const VIDIOC_SUBDEV_S_EDID: u32 = 3223606825;
+pub const MATROXFB_SET_OUTPUT_MODE: u32 = 1074032378;
+pub const RIO_DEV_ADD: u32 = 1075866903;
+pub const VIDIOC_ENUM_FREQ_BANDS: u32 = 3225441893;
+pub const FBIO_RADEON_SET_MIRROR: u32 = 1074020356;
+pub const PCITEST_GET_IRQTYPE: u32 = 20489;
+pub const JSIOCGVERSION: u32 = 2147772929;
+pub const SONYPI_IOCSBLUE: u32 = 1073837577;
+pub const SNAPSHOT_PREF_IMAGE_SIZE: u32 = 13074;
+pub const F2FS_IOC_GET_FEATURES: u32 = 2147808524;
+pub const SCIF_REG: u32 = 3223876360;
+pub const NILFS_IOCTL_CLEAN_SEGMENTS: u32 = 1081634440;
+pub const FW_CDEV_IOC_INITIATE_BUS_RESET: u32 = 1074012933;
+pub const RIO_WAIT_FOR_ASYNC: u32 = 1074294038;
+pub const VHOST_SET_VRING_NUM: u32 = 1074310928;
+pub const AUTOFS_DEV_IOCTL_PROTOVER: u32 = 3222836082;
+pub const RIO_FREE_DMA: u32 = 1074294036;
+pub const MGSL_IOCRXENABLE: u32 = 27909;
+pub const IOCTL_VM_SOCKETS_GET_LOCAL_CID: u32 = 1977;
+pub const IPMICTL_SET_TIMING_PARMS_CMD: u32 = 2148034838;
+pub const PPPIOCGL2TPSTATS: u32 = 2152231990;
+pub const PERF_EVENT_IOC_PERIOD: u32 = 1074275332;
+pub const PTP_PIN_SETFUNC2: u32 = 1080048912;
+pub const CHIOEXCHANGE: u32 = 1075602178;
+pub const NILFS_IOCTL_GET_SUINFO: u32 = 2149084804;
+pub const CEC_DQEVENT: u32 = 3226493191;
+pub const UI_SET_SWBIT: u32 = 1074025837;
+pub const VHOST_VDPA_SET_CONFIG: u32 = 1074311028;
+pub const TUNSETIFF: u32 = 1074025674;
+pub const CHIOPOSITION: u32 = 1074553603;
+pub const IPMICTL_SET_MAINTENANCE_MODE_CMD: u32 = 1074030879;
+pub const BTRFS_IOC_DEFAULT_SUBVOL: u32 = 1074304019;
+pub const RIO_UNMAP_OUTBOUND: u32 = 1076391184;
+pub const CAPI_CLR_FLAGS: u32 = 2147762981;
+pub const FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE_ONCE: u32 = 1075323663;
+pub const MATROXFB_GET_OUTPUT_CONNECTION: u32 = 2147774200;
+pub const EVIOCSMASK: u32 = 1074808211;
+pub const BTRFS_IOC_FORGET_DEV: u32 = 1342215173;
+pub const CXL_MEM_QUERY_COMMANDS: u32 = 2148060673;
+pub const CEC_S_MODE: u32 = 1074028809;
+pub const MGSL_IOCSIF: u32 = 27914;
+pub const SWITCHTEC_IOCTL_PFF_TO_PORT: u32 = 3222034244;
+pub const PPSETMODE: u32 = 1074032768;
+pub const VFIO_DEVICE_SET_IRQS: u32 = 15214;
+pub const VIDIOC_PREPARE_BUF: u32 = 3225704029;
+pub const CEC_ADAP_G_CONNECTOR_INFO: u32 = 2151964938;
+pub const IOC_OPAL_WRITE_SHADOW_MBR: u32 = 1092645098;
+pub const VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: u32 = 3225441867;
+pub const UDMABUF_CREATE: u32 = 1075344706;
+pub const SONET_CLRDIAG: u32 = 3221512467;
+pub const PHN_SET_REG: u32 = 1074032641;
+pub const RNDADDTOENTCNT: u32 = 1074024961;
+pub const VBG_IOCTL_CHECK_BALLOON: u32 = 3223344657;
+pub const VIDIOC_OMAP3ISP_STAT_REQ: u32 = 3222820550;
+pub const PPS_FETCH: u32 = 3221516452;
+pub const RTC_AIE_OFF: u32 = 28674;
+pub const VFIO_GROUP_SET_CONTAINER: u32 = 15208;
+pub const FW_CDEV_IOC_RECEIVE_PHY_PACKETS: u32 = 1074275094;
+pub const VFIO_IOMMU_SPAPR_TCE_REMOVE: u32 = 15224;
+pub const VFIO_IOMMU_GET_INFO: u32 = 15216;
+pub const DM_DEV_SUSPEND: u32 = 3241737478;
+pub const F2FS_IOC_GET_COMPRESS_OPTION: u32 = 2147677461;
+pub const FW_CDEV_IOC_STOP_ISO: u32 = 1074012939;
+pub const GPIO_V2_GET_LINEINFO_IOCTL: u32 = 3238048773;
+pub const ATMMPC_CTRL: u32 = 25048;
+pub const PPPIOCSXASYNCMAP: u32 = 1075868751;
+pub const CHIOGSTATUS: u32 = 1074291464;
+pub const FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE: u32 = 3222807309;
+pub const RIO_MPORT_MAINT_PORT_IDX_GET: u32 = 2147773699;
+pub const CAPI_SET_FLAGS: u32 = 2147762980;
+pub const VFIO_GROUP_GET_DEVICE_FD: u32 = 15210;
+pub const VHOST_SET_MEM_TABLE: u32 = 1074310915;
+pub const MATROXFB_SET_OUTPUT_CONNECTION: u32 = 1074032376;
+pub const DFL_FPGA_PORT_GET_REGION_INFO: u32 = 46658;
+pub const VHOST_GET_FEATURES: u32 = 2148052736;
+pub const LIRC_GET_REC_RESOLUTION: u32 = 2147772679;
+pub const PACKET_CTRL_CMD: u32 = 3222820865;
+pub const LIRC_SET_TRANSMITTER_MASK: u32 = 1074030871;
+pub const BTRFS_IOC_ADD_DEV: u32 = 1342215178;
+pub const JSIOCGCORR: u32 = 2149870114;
+pub const VIDIOC_G_FMT: u32 = 3234616836;
+pub const RTC_EPOCH_SET: u32 = 1074032654;
+pub const CAPI_GET_PROFILE: u32 = 3225436937;
+pub const ATM_GETLOOP: u32 = 1074553170;
+pub const SCIF_LISTEN: u32 = 1074033410;
+pub const NBD_CLEAR_QUE: u32 = 43781;
+pub const F2FS_IOC_MOVE_RANGE: u32 = 3223123209;
+pub const LIRC_GET_LENGTH: u32 = 2147772687;
+pub const I8K_SET_FAN: u32 = 3221514631;
+pub const FDSETMAXERRS: u32 = 1075053132;
+pub const VIDIOC_SUBDEV_QUERYCAP: u32 = 2151699968;
+pub const SNAPSHOT_SET_SWAP_AREA: u32 = 1074541325;
+pub const LIRC_GET_REC_TIMEOUT: u32 = 2147772708;
+pub const EVIOCRMFF: u32 = 1074021761;
+pub const GPIO_GET_LINEEVENT_IOCTL: u32 = 3224417284;
+pub const PPRDATA: u32 = 2147577989;
+pub const RIO_MPORT_GET_PROPERTIES: u32 = 2150657284;
+pub const TUNSETVNETHDRSZ: u32 = 1074025688;
+pub const GPIO_GET_LINEINFO_IOCTL: u32 = 3225990146;
+pub const GSMIOC_GETCONF: u32 = 2152482560;
+pub const LIRC_GET_SEND_MODE: u32 = 2147772673;
+pub const PPPIOCSACTIVE: u32 = 1074295878;
+pub const SIOCGSTAMPNS_NEW: u32 = 2148567303;
+pub const IPMICTL_RECEIVE_MSG: u32 = 3222825228;
+pub const LIRC_SET_SEND_DUTY_CYCLE: u32 = 1074030869;
+pub const UI_END_FF_ERASE: u32 = 1074550219;
+pub const SWITCHTEC_IOCTL_FLASH_PART_INFO: u32 = 3222296385;
+pub const FW_CDEV_IOC_SEND_PHY_PACKET: u32 = 3222545173;
+pub const NBD_SET_FLAGS: u32 = 43786;
+pub const VFIO_DEVICE_GET_REGION_INFO: u32 = 15212;
+pub const REISERFS_IOC_UNPACK: u32 = 1074056449;
+pub const FW_CDEV_IOC_REMOVE_DESCRIPTOR: u32 = 1074012935;
+pub const RIO_SET_EVENT_MASK: u32 = 1074031885;
+pub const SNAPSHOT_ALLOC_SWAP_PAGE: u32 = 2148021012;
+pub const VDUSE_VQ_INJECT_IRQ: u32 = 1074037015;
+pub const I2OPASSTHRU: u32 = 2148034828;
+pub const IOC_OPAL_SET_PW: u32 = 1109422304;
+pub const FSI_SCOM_READ: u32 = 3223352065;
+pub const VHOST_VDPA_GET_DEVICE_ID: u32 = 2147790704;
+pub const VIDIOC_QBUF: u32 = 3225703951;
+pub const VIDIOC_S_TUNER: u32 = 1079268894;
+pub const TUNGETVNETHDRSZ: u32 = 2147767511;
+pub const CAPI_NCCI_GETUNIT: u32 = 2147762983;
+pub const DFL_FPGA_PORT_UINT_GET_IRQ_NUM: u32 = 2147792455;
+pub const VIDIOC_OMAP3ISP_STAT_EN: u32 = 3221509831;
+pub const GPIO_V2_LINE_SET_CONFIG_IOCTL: u32 = 3239097357;
+pub const TEE_IOC_VERSION: u32 = 2148312064;
+pub const VIDIOC_LOG_STATUS: u32 = 22086;
+pub const IPMICTL_SEND_COMMAND_SETTIME: u32 = 2149345557;
+pub const VHOST_SET_LOG_FD: u32 = 1074048775;
+pub const SCIF_SEND: u32 = 3222565638;
+pub const VIDIOC_SUBDEV_G_FMT: u32 = 3227014660;
+pub const NS_ADJBUFLEV: u32 = 24931;
+pub const VIDIOC_DBG_S_REGISTER: u32 = 1077433935;
+pub const NILFS_IOCTL_RESIZE: u32 = 1074294411;
+pub const PHN_GETREG: u32 = 3221778437;
+pub const I2OSWDL: u32 = 3223087365;
+pub const VBG_IOCTL_VMMDEV_REQUEST_BIG: u32 = 22019;
+pub const JSIOCGBUTTONS: u32 = 2147576338;
+pub const VFIO_IOMMU_ENABLE: u32 = 15219;
+pub const DM_DEV_RENAME: u32 = 3241737477;
+pub const MEDIA_IOC_SETUP_LINK: u32 = 3224665091;
+pub const VIDIOC_ENUMOUTPUT: u32 = 3225966128;
+pub const STP_POLICY_ID_SET: u32 = 3222283520;
+pub const VHOST_VDPA_SET_CONFIG_CALL: u32 = 1074048887;
+pub const VIDIOC_SUBDEV_G_CROP: u32 = 3224917563;
+pub const VIDIOC_S_CROP: u32 = 1075074620;
+pub const WDIOC_GETTEMP: u32 = 2147768067;
+pub const IOC_OPAL_ADD_USR_TO_LR: u32 = 1092120804;
+pub const UI_SET_LEDBIT: u32 = 1074025833;
+pub const NBD_SET_SOCK: u32 = 43776;
+pub const BTRFS_IOC_SNAP_DESTROY_V2: u32 = 1342215231;
+pub const HIDIOCGCOLLECTIONINFO: u32 = 3222292497;
+pub const I2OSWUL: u32 = 3223087366;
+pub const IOCTL_MEI_NOTIFY_GET: u32 = 2147764227;
+pub const FDFMTTRK: u32 = 1074528840;
+pub const MMTIMER_GETBITS: u32 = 27908;
+pub const VIDIOC_ENUMSTD: u32 = 3225441817;
+pub const VHOST_GET_VRING_BASE: u32 = 3221794578;
+pub const VFIO_DEVICE_IOEVENTFD: u32 = 15220;
+pub const ATMARP_SETENTRY: u32 = 25059;
+pub const CCISS_REVALIDVOLS: u32 = 16906;
+pub const MGSL_IOCLOOPTXDONE: u32 = 27913;
+pub const RTC_VL_READ: u32 = 2147774483;
+pub const ND_IOCTL_ARS_STATUS: u32 = 3224391171;
+pub const RIO_DEV_DEL: u32 = 1075866904;
+pub const VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES: u32 = 3223606797;
+pub const VIDIOC_SUBDEV_DV_TIMINGS_CAP: u32 = 3230684772;
+pub const SONYPI_IOCSFAN: u32 = 1073837579;
+pub const SPIOCSTYPE: u32 = 1074032897;
+pub const IPMICTL_REGISTER_FOR_CMD: u32 = 2147641614;
+pub const I8K_GET_FAN: u32 = 3221514630;
+pub const TUNGETVNETBE: u32 = 2147767519;
+pub const AUTOFS_DEV_IOCTL_FAIL: u32 = 3222836087;
+pub const UI_END_FF_UPLOAD: u32 = 1080055241;
+pub const TOSH_SMM: u32 = 3222828176;
+pub const SONYPI_IOCGBAT2REM: u32 = 2147644933;
+pub const F2FS_IOC_GET_COMPRESS_BLOCKS: u32 = 2148070673;
+pub const PPPIOCSNPMODE: u32 = 1074295883;
+pub const USBDEVFS_CONTROL: u32 = 3222295808;
+pub const HIDIOCGUSAGE: u32 = 3222816779;
+pub const TUNSETTXFILTER: u32 = 1074025681;
+pub const TUNGETVNETLE: u32 = 2147767517;
+pub const VIDIOC_ENUM_DV_TIMINGS: u32 = 3230946914;
+pub const BTRFS_IOC_INO_PATHS: u32 = 3224933411;
+pub const MGSL_IOCGXSYNC: u32 = 27924;
+pub const HIDIOCGFIELDINFO: u32 = 3224913930;
+pub const VIDIOC_SUBDEV_G_STD: u32 = 2148029975;
+pub const I2OVALIDATE: u32 = 2147772680;
+pub const VIDIOC_TRY_ENCODER_CMD: u32 = 3223869006;
+pub const NILFS_IOCTL_GET_CPINFO: u32 = 2149084802;
+pub const VIDIOC_G_FREQUENCY: u32 = 3224131128;
+pub const VFAT_IOCTL_READDIR_SHORT: u32 = 2182640130;
+pub const ND_IOCTL_GET_CONFIG_DATA: u32 = 3222031877;
+pub const F2FS_IOC_RESERVE_COMPRESS_BLOCKS: u32 = 2148070675;
+pub const FDGETDRVSTAT: u32 = 2150892050;
+pub const SYNC_IOC_MERGE: u32 = 3224387075;
+pub const VIDIOC_S_DV_TIMINGS: u32 = 3229898327;
+pub const PPPIOCBRIDGECHAN: u32 = 1074033717;
+pub const LIRC_SET_SEND_MODE: u32 = 1074030865;
+pub const RIO_ENABLE_PORTWRITE_RANGE: u32 = 1074818315;
+pub const ATM_GETTYPE: u32 = 1074553220;
+pub const PHN_GETREGS: u32 = 3223875591;
+pub const FDSETEMSGTRESH: u32 = 586;
+pub const NILFS_IOCTL_GET_VINFO: u32 = 3222826630;
+pub const MGSL_IOCWAITEVENT: u32 = 3221515528;
+pub const CAPI_INSTALLED: u32 = 2147631906;
+pub const EVIOCGMASK: u32 = 2148550034;
+pub const BTRFS_IOC_SUBVOL_GETFLAGS: u32 = 2148045849;
+pub const FSL_HV_IOCTL_PARTITION_GET_STATUS: u32 = 3222056706;
+pub const MEDIA_IOC_ENUM_ENTITIES: u32 = 3238034433;
+pub const GSMIOC_GETFIRST: u32 = 2147763972;
+pub const FW_CDEV_IOC_FLUSH_ISO: u32 = 1074012952;
+pub const VIDIOC_DBG_G_CHIP_INFO: u32 = 3234354790;
+pub const F2FS_IOC_RELEASE_VOLATILE_WRITE: u32 = 62724;
+pub const CAPI_GET_SERIAL: u32 = 3221504776;
+pub const FDSETDRVPRM: u32 = 1079509648;
+pub const IOC_OPAL_SAVE: u32 = 1092120796;
+pub const VIDIOC_G_DV_TIMINGS: u32 = 3229898328;
+pub const TUNSETIFINDEX: u32 = 1074025690;
+pub const CCISS_SETINTINFO: u32 = 1074283011;
+pub const RTC_VL_CLR: u32 = 28692;
+pub const VIDIOC_REQBUFS: u32 = 3222558216;
+pub const USBDEVFS_REAPURBNDELAY32: u32 = 1074025741;
+pub const TEE_IOC_SHM_REGISTER: u32 = 3222840329;
+pub const USBDEVFS_SETCONFIGURATION: u32 = 2147767557;
+pub const CCISS_GETNODENAME: u32 = 2148549124;
+pub const VIDIOC_SUBDEV_S_FRAME_INTERVAL: u32 = 3224393238;
+pub const VIDIOC_ENUM_FRAMESIZES: u32 = 3224131146;
+pub const VFIO_DEVICE_PCI_HOT_RESET: u32 = 15217;
+pub const FW_CDEV_IOC_SEND_BROADCAST_REQUEST: u32 = 1076110098;
+pub const LPSETTIMEOUT_NEW: u32 = 1074791951;
+pub const RIO_CM_MPORT_GET_LIST: u32 = 3221512971;
+pub const FW_CDEV_IOC_QUEUE_ISO: u32 = 3222807305;
+pub const FDRAWCMD: u32 = 600;
+pub const SCIF_UNREG: u32 = 3222303497;
+pub const PPPIOCGIDLE64: u32 = 2148561983;
+pub const USBDEVFS_RELEASEINTERFACE: u32 = 2147767568;
+pub const VIDIOC_CROPCAP: u32 = 3224131130;
+pub const DFL_FPGA_PORT_GET_INFO: u32 = 46657;
+pub const PHN_SET_REGS: u32 = 1074032643;
+pub const ATMLEC_DATA: u32 = 25041;
+pub const PPPOEIOCDFWD: u32 = 45313;
+pub const VIDIOC_S_SELECTION: u32 = 3225441887;
+pub const SNAPSHOT_FREE_SWAP_PAGES: u32 = 13065;
+pub const BTRFS_IOC_LOGICAL_INO: u32 = 3224933412;
+pub const VIDIOC_S_CTRL: u32 = 3221771804;
+pub const ZATM_SETPOOL: u32 = 1074553187;
+pub const MTIOCPOS: u32 = 2147773699;
+pub const PMU_IOC_SLEEP: u32 = 16896;
+pub const AUTOFS_DEV_IOCTL_PROTOSUBVER: u32 = 3222836083;
+pub const VBG_IOCTL_CHANGE_FILTER_MASK: u32 = 3223344652;
+pub const NILFS_IOCTL_GET_SUSTAT: u32 = 2150657669;
+pub const VIDIOC_QUERYCAP: u32 = 2154321408;
+pub const HPET_INFO: u32 = 2148296707;
+pub const VIDIOC_AM437X_CCDC_CFG: u32 = 1074026177;
+pub const DM_LIST_DEVICES: u32 = 3241737474;
+pub const TUNSETOWNER: u32 = 1074025676;
+pub const VBG_IOCTL_CHANGE_GUEST_CAPABILITIES: u32 = 3223344654;
+pub const RNDADDENTROPY: u32 = 1074287107;
+pub const USBDEVFS_RESET: u32 = 21780;
+pub const BTRFS_IOC_SUBVOL_CREATE: u32 = 1342215182;
+pub const USBDEVFS_FORBID_SUSPEND: u32 = 21793;
+pub const FDGETDRVTYP: u32 = 2148532751;
+pub const PPWCONTROL: u32 = 1073836164;
+pub const VIDIOC_ENUM_FRAMEINTERVALS: u32 = 3224655435;
+pub const KCOV_DISABLE: u32 = 25445;
+pub const IOC_OPAL_ACTIVATE_LSP: u32 = 1092120799;
+pub const VHOST_VDPA_GET_IOVA_RANGE: u32 = 2148577144;
+pub const PPPIOCSPASS: u32 = 1074295879;
+pub const RIO_CM_CHAN_CONNECT: u32 = 1074291464;
+pub const I2OSWDEL: u32 = 3223087367;
+pub const FS_IOC_SET_ENCRYPTION_POLICY: u32 = 2148296211;
+pub const IOC_OPAL_MBR_DONE: u32 = 1091596521;
+pub const PPPIOCSMAXCID: u32 = 1074033745;
+pub const PPSETPHASE: u32 = 1074032788;
+pub const VHOST_VDPA_SET_VRING_ENABLE: u32 = 1074311029;
+pub const USBDEVFS_GET_SPEED: u32 = 21791;
+pub const SONET_GETFRAMING: u32 = 2147770646;
+pub const VIDIOC_QUERYBUF: u32 = 3225703945;
+pub const VIDIOC_S_EDID: u32 = 3223606825;
+pub const BTRFS_IOC_QGROUP_ASSIGN: u32 = 1075352617;
+pub const PPS_GETCAP: u32 = 2147774627;
+pub const SNAPSHOT_PLATFORM_SUPPORT: u32 = 13071;
+pub const LIRC_SET_REC_TIMEOUT_REPORTS: u32 = 1074030873;
+pub const SCIF_GET_NODEIDS: u32 = 3222565646;
+pub const NBD_DISCONNECT: u32 = 43784;
+pub const VIDIOC_SUBDEV_G_FRAME_INTERVAL: u32 = 3224393237;
+pub const VFIO_IOMMU_DISABLE: u32 = 15220;
+pub const SNAPSHOT_CREATE_IMAGE: u32 = 1074017041;
+pub const SNAPSHOT_POWER_OFF: u32 = 13072;
+pub const APM_IOC_STANDBY: u32 = 16641;
+pub const PPPIOCGUNIT: u32 = 2147775574;
+pub const AUTOFS_IOC_EXPIRE_MULTI: u32 = 1074041702;
+pub const SCIF_BIND: u32 = 3221779201;
+pub const IOC_WATCH_QUEUE_SET_SIZE: u32 = 22368;
+pub const NILFS_IOCTL_CHANGE_CPMODE: u32 = 1074818688;
+pub const IOC_OPAL_LOCK_UNLOCK: u32 = 1092120797;
+pub const F2FS_IOC_SET_PIN_FILE: u32 = 1074066701;
+pub const PPPIOCGRASYNCMAP: u32 = 2147775573;
+pub const MMTIMER_MMAPAVAIL: u32 = 27910;
+pub const I2OPASSTHRU32: u32 = 2148034828;
+pub const DFL_FPGA_FME_PORT_RELEASE: u32 = 1074050689;
+pub const VIDIOC_SUBDEV_QUERY_DV_TIMINGS: u32 = 2156156515;
+pub const UI_SET_SNDBIT: u32 = 1074025834;
+pub const VIDIOC_G_AUDOUT: u32 = 2150913585;
+pub const RTC_PLL_SET: u32 = 1075605522;
+pub const VIDIOC_ENUMAUDIO: u32 = 3224655425;
+pub const AUTOFS_DEV_IOCTL_TIMEOUT: u32 = 3222836090;
+pub const VBG_IOCTL_DRIVER_VERSION_INFO: u32 = 3224131072;
+pub const VHOST_SCSI_GET_EVENTS_MISSED: u32 = 1074048836;
+pub const VHOST_SET_VRING_ADDR: u32 = 1076408081;
+pub const VDUSE_CREATE_DEV: u32 = 1095794946;
+pub const FDFLUSH: u32 = 587;
+pub const VBG_IOCTL_WAIT_FOR_EVENTS: u32 = 3223344650;
+pub const DFL_FPGA_FME_ERR_SET_IRQ: u32 = 1074312836;
+pub const F2FS_IOC_GET_PIN_FILE: u32 = 2147808526;
+pub const SCIF_CONNECT: u32 = 3221779203;
+pub const BLKREPORTZONE: u32 = 3222278786;
+pub const AUTOFS_IOC_ASKUMOUNT: u32 = 2147783536;
+pub const ATM_ADDPARTY: u32 = 1074291188;
+pub const FDSETPRM: u32 = 1075577410;
+pub const ATM_GETSTATZ: u32 = 1074553169;
+pub const ISST_IF_MSR_COMMAND: u32 = 3221552644;
+pub const BTRFS_IOC_GET_SUBVOL_INFO: u32 = 2179503164;
+pub const VIDIOC_UNSUBSCRIBE_EVENT: u32 = 1075861083;
+pub const SEV_ISSUE_CMD: u32 = 3222295296;
+pub const GPIOHANDLE_SET_LINE_VALUES_IOCTL: u32 = 3225465865;
+pub const PCITEST_COPY: u32 = 1074024454;
+pub const IPMICTL_GET_MY_ADDRESS_CMD: u32 = 2147772690;
+pub const CHIOGPICKER: u32 = 2147771140;
+pub const CAPI_NCCI_OPENCOUNT: u32 = 2147762982;
+pub const CXL_MEM_SEND_COMMAND: u32 = 3224423938;
+pub const PERF_EVENT_IOC_SET_FILTER: u32 = 1074013190;
+pub const IOC_OPAL_REVERT_TPR: u32 = 1091072226;
+pub const CHIOGVPARAMS: u32 = 2154849043;
+pub const PTP_PEROUT_REQUEST: u32 = 1077427459;
+pub const FSI_SCOM_CHECK: u32 = 2147775232;
+pub const RTC_IRQP_READ: u32 = 2147774475;
+pub const RIO_MPORT_MAINT_READ_LOCAL: u32 = 2149084421;
+pub const HIDIOCGRDESCSIZE: u32 = 2147764225;
+pub const UI_GET_VERSION: u32 = 2147767597;
+pub const NILFS_IOCTL_GET_CPSTAT: u32 = 2149084803;
+pub const CCISS_GETBUSTYPES: u32 = 2147762695;
+pub const VFIO_IOMMU_SPAPR_TCE_CREATE: u32 = 15223;
+pub const VIDIOC_EXPBUF: u32 = 3225441808;
+pub const UI_SET_RELBIT: u32 = 1074025830;
+pub const VFIO_SET_IOMMU: u32 = 15206;
+pub const VIDIOC_S_MODULATOR: u32 = 1078220343;
+pub const TUNGETFILTER: u32 = 2148029659;
+pub const CCISS_SETNODENAME: u32 = 1074807301;
+pub const FBIO_GETCONTROL2: u32 = 2147763849;
+pub const TUNSETDEBUG: u32 = 1074025673;
+pub const DM_DEV_REMOVE: u32 = 3241737476;
+pub const HIDIOCSUSAGES: u32 = 1344030740;
+pub const FS_IOC_ADD_ENCRYPTION_KEY: u32 = 3226494487;
+pub const FBIOGET_VBLANK: u32 = 2149598738;
+pub const ATM_GETSTAT: u32 = 1074553168;
+pub const VIDIOC_G_JPEGCOMP: u32 = 2156680765;
+pub const TUNATTACHFILTER: u32 = 1074287829;
+pub const UI_SET_ABSBIT: u32 = 1074025831;
+pub const DFL_FPGA_PORT_ERR_GET_IRQ_NUM: u32 = 2147792453;
+pub const USBDEVFS_REAPURB32: u32 = 1074025740;
+pub const BTRFS_IOC_TRANS_END: u32 = 37895;
+pub const CAPI_REGISTER: u32 = 1074545409;
+pub const F2FS_IOC_COMPRESS_FILE: u32 = 62744;
+pub const USBDEVFS_DISCARDURB: u32 = 21771;
+pub const HE_GET_REG: u32 = 1074553184;
+pub const ATM_SETLOOP: u32 = 1074553171;
+pub const ATMSIGD_CTRL: u32 = 25072;
+pub const CIOC_KERNEL_VERSION: u32 = 3221512970;
+pub const BTRFS_IOC_CLONE_RANGE: u32 = 1075876877;
+pub const SNAPSHOT_UNFREEZE: u32 = 13058;
+pub const F2FS_IOC_START_VOLATILE_WRITE: u32 = 62723;
+pub const PMU_IOC_HAS_ADB: u32 = 2147762692;
+pub const I2OGETIOPS: u32 = 2149607680;
+pub const VIDIOC_S_FBUF: u32 = 1076647435;
+pub const PPRCONTROL: u32 = 2147577987;
+pub const CHIOSPICKER: u32 = 1074029317;
+pub const VFIO_IOMMU_SPAPR_REGISTER_MEMORY: u32 = 15221;
+pub const TUNGETSNDBUF: u32 = 2147767507;
+pub const GSMIOC_SETCONF: u32 = 1078740737;
+pub const IOC_PR_PREEMPT: u32 = 1075343563;
+pub const KCOV_INIT_TRACE: u32 = 2147771137;
+pub const SONYPI_IOCGBAT1CAP: u32 = 2147644930;
+pub const SWITCHTEC_IOCTL_FLASH_INFO: u32 = 2148554560;
+pub const MTIOCTOP: u32 = 1074294017;
+pub const VHOST_VDPA_SET_STATUS: u32 = 1073852274;
+pub const VHOST_SCSI_SET_EVENTS_MISSED: u32 = 1074048835;
+pub const VFIO_IOMMU_DIRTY_PAGES: u32 = 15221;
+pub const BTRFS_IOC_SCRUB_PROGRESS: u32 = 3288372253;
+pub const PPPIOCGMRU: u32 = 2147775571;
+pub const BTRFS_IOC_DEV_REPLACE: u32 = 3391394869;
+pub const PPPIOCGFLAGS: u32 = 2147775578;
+pub const NILFS_IOCTL_SET_SUINFO: u32 = 1075342989;
+pub const FW_CDEV_IOC_GET_CYCLE_TIMER2: u32 = 3222545172;
+pub const ATM_DELLECSADDR: u32 = 1074553231;
+pub const FW_CDEV_IOC_GET_SPEED: u32 = 8977;
+pub const PPPIOCGIDLE32: u32 = 2148037695;
+pub const VFIO_DEVICE_RESET: u32 = 15215;
+pub const GPIO_GET_LINEINFO_UNWATCH_IOCTL: u32 = 3221533708;
+pub const WDIOC_GETSTATUS: u32 = 2147768065;
+pub const BTRFS_IOC_SET_FEATURES: u32 = 1076925497;
+pub const IOCTL_MEI_CONNECT_CLIENT: u32 = 3222292481;
+pub const VIDIOC_OMAP3ISP_AEWB_CFG: u32 = 3223344835;
+pub const PCITEST_READ: u32 = 1074024453;
+pub const VFIO_GROUP_GET_STATUS: u32 = 15207;
+pub const MATROXFB_GET_ALL_OUTPUTS: u32 = 2147774203;
+pub const USBDEVFS_CLEAR_HALT: u32 = 2147767573;
+pub const VIDIOC_DECODER_CMD: u32 = 3225966176;
+pub const VIDIOC_G_AUDIO: u32 = 2150913569;
+pub const CCISS_RESCANDISK: u32 = 16912;
+pub const RIO_DISABLE_PORTWRITE_RANGE: u32 = 1074818316;
+pub const IOC_OPAL_SECURE_ERASE_LR: u32 = 1091596519;
+pub const USBDEVFS_REAPURB: u32 = 1074025740;
+pub const DFL_FPGA_CHECK_EXTENSION: u32 = 46593;
+pub const AUTOFS_IOC_PROTOVER: u32 = 2147783523;
+pub const FSL_HV_IOCTL_MEMCPY: u32 = 3223891717;
+pub const BTRFS_IOC_GET_FEATURES: u32 = 2149094457;
+pub const PCITEST_MSIX: u32 = 1074024455;
+pub const BTRFS_IOC_DEFRAG_RANGE: u32 = 1076925456;
+pub const UI_BEGIN_FF_ERASE: u32 = 3222033866;
+pub const DM_GET_TARGET_VERSION: u32 = 3241737489;
+pub const PPPIOCGIDLE: u32 = 2148037695;
+pub const NVRAM_SETCKS: u32 = 28737;
+pub const WDIOC_GETSUPPORT: u32 = 2150127360;
+pub const GSMIOC_ENABLE_NET: u32 = 1077167874;
+pub const GPIO_GET_CHIPINFO_IOCTL: u32 = 2151986177;
+pub const NE_ADD_VCPU: u32 = 3221532193;
+pub const EVIOCSKEYCODE_V2: u32 = 1076380932;
+pub const PTP_SYS_OFFSET_EXTENDED2: u32 = 3300932882;
+pub const SCIF_FENCE_WAIT: u32 = 3221517072;
+pub const RIO_TRANSFER: u32 = 3222826261;
+pub const FSL_HV_IOCTL_DOORBELL: u32 = 3221794566;
+pub const RIO_MPORT_MAINT_WRITE_LOCAL: u32 = 1075342598;
+pub const I2OEVTREG: u32 = 1074555146;
+pub const I2OPARMGET: u32 = 3222825220;
+pub const EVIOCGID: u32 = 2148025602;
+pub const BTRFS_IOC_QGROUP_CREATE: u32 = 1074828330;
+pub const AUTOFS_DEV_IOCTL_SETPIPEFD: u32 = 3222836088;
+pub const VIDIOC_S_PARM: u32 = 3234616854;
+pub const TUNSETSTEERINGEBPF: u32 = 2147767520;
+pub const ATM_GETNAMES: u32 = 1074291075;
+pub const VIDIOC_QUERYMENU: u32 = 3224131109;
+pub const DFL_FPGA_PORT_DMA_UNMAP: u32 = 46660;
+pub const I2OLCTGET: u32 = 3222038786;
+pub const FS_IOC_GET_ENCRYPTION_PWSALT: u32 = 1074816532;
+pub const NS_SETBUFLEV: u32 = 1074553186;
+pub const BLKCLOSEZONE: u32 = 1074795143;
+pub const SONET_GETFRSENSE: u32 = 2147901719;
+pub const UI_SET_EVBIT: u32 = 1074025828;
+pub const DM_LIST_VERSIONS: u32 = 3241737485;
+pub const HIDIOCGSTRING: u32 = 2164541444;
+pub const PPPIOCATTCHAN: u32 = 1074033720;
+pub const VDUSE_DEV_SET_CONFIG: u32 = 1074299154;
+pub const TUNGETFEATURES: u32 = 2147767503;
+pub const VFIO_GROUP_UNSET_CONTAINER: u32 = 15209;
+pub const IPMICTL_SET_MY_ADDRESS_CMD: u32 = 2147772689;
+pub const CCISS_REGNEWDISK: u32 = 1074020877;
+pub const VIDIOC_QUERY_DV_TIMINGS: u32 = 2156156515;
+pub const PHN_SETREGS: u32 = 1076391944;
+pub const FAT_IOCTL_GET_ATTRIBUTES: u32 = 2147774992;
+pub const FSL_MC_SEND_MC_COMMAND: u32 = 3225440992;
+pub const TUNGETIFF: u32 = 2147767506;
+pub const PTP_CLOCK_GETCAPS2: u32 = 2152742154;
+pub const BTRFS_IOC_RESIZE: u32 = 1342215171;
+pub const VHOST_SET_VRING_ENDIAN: u32 = 1074310931;
+pub const PPS_KC_BIND: u32 = 1074032805;
+pub const F2FS_IOC_WRITE_CHECKPOINT: u32 = 62727;
+pub const UI_SET_FFBIT: u32 = 1074025835;
+pub const IPMICTL_GET_MY_LUN_CMD: u32 = 2147772692;
+pub const CEC_ADAP_G_PHYS_ADDR: u32 = 2147639553;
+pub const CEC_G_MODE: u32 = 2147770632;
+pub const USBDEVFS_RESETEP: u32 = 2147767555;
+pub const MEDIA_REQUEST_IOC_QUEUE: u32 = 31872;
+pub const USBDEVFS_ALLOC_STREAMS: u32 = 2148029724;
+pub const MGSL_IOCSXCTRL: u32 = 27925;
+pub const MEDIA_IOC_G_TOPOLOGY: u32 = 3225975812;
+pub const PPPIOCUNBRIDGECHAN: u32 = 29748;
+pub const F2FS_IOC_COMMIT_ATOMIC_WRITE: u32 = 62722;
+pub const ISST_IF_GET_PLATFORM_INFO: u32 = 2147810816;
+pub const SCIF_FENCE_MARK: u32 = 3222041359;
+pub const USBDEVFS_RELEASE_PORT: u32 = 2147767577;
+pub const VFIO_CHECK_EXTENSION: u32 = 15205;
+pub const BTRFS_IOC_QGROUP_LIMIT: u32 = 2150667307;
+pub const FAT_IOCTL_GET_VOLUME_ID: u32 = 2147774995;
+pub const UI_SET_PHYS: u32 = 1074025836;
+pub const FDWERRORGET: u32 = 2149057047;
+pub const VIDIOC_SUBDEV_G_EDID: u32 = 3223606824;
+pub const MGSL_IOCGSTATS: u32 = 27911;
+pub const RPROC_SET_SHUTDOWN_ON_RELEASE: u32 = 1074050817;
+pub const SIOCGSTAMP_NEW: u32 = 2148567302;
+pub const RTC_WKALM_RD: u32 = 2150133776;
+pub const PHN_GET_REG: u32 = 3221516288;
+pub const DELL_WMI_SMBIOS_CMD: u32 = 3224655616;
+pub const PHN_NOT_OH: u32 = 28676;
+pub const PPGETMODES: u32 = 2147774615;
+pub const CHIOGPARAMS: u32 = 2148819718;
+pub const VFIO_DEVICE_GET_GFX_DMABUF: u32 = 15219;
+pub const VHOST_SET_VRING_BUSYLOOP_TIMEOUT: u32 = 1074310947;
+pub const VIDIOC_SUBDEV_G_SELECTION: u32 = 3225441853;
+pub const BTRFS_IOC_RM_DEV_V2: u32 = 1342215226;
+pub const MGSL_IOCWAITGPIO: u32 = 3222301970;
+pub const PMU_IOC_CAN_SLEEP: u32 = 2147762693;
+pub const KCOV_ENABLE: u32 = 25444;
+pub const BTRFS_IOC_CLONE: u32 = 1074041865;
+pub const F2FS_IOC_DEFRAGMENT: u32 = 3222336776;
+pub const FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE: u32 = 1074012942;
+pub const AGPIOC_ALLOCATE: u32 = 3221504262;
+pub const NE_SET_USER_MEMORY_REGION: u32 = 1075359267;
+pub const MGSL_IOCTXABORT: u32 = 27910;
+pub const MGSL_IOCSGPIO: u32 = 1074818320;
+pub const LIRC_SET_REC_CARRIER: u32 = 1074030868;
+pub const F2FS_IOC_FLUSH_DEVICE: u32 = 1074328842;
+pub const SNAPSHOT_ATOMIC_RESTORE: u32 = 13060;
+pub const RTC_UIE_OFF: u32 = 28676;
+pub const BT_BMC_IOCTL_SMS_ATN: u32 = 45312;
+pub const NVME_IOCTL_ID: u32 = 20032;
+pub const NE_START_ENCLAVE: u32 = 3222318628;
+pub const VIDIOC_STREAMON: u32 = 1074026002;
+pub const FDPOLLDRVSTAT: u32 = 2150892051;
+pub const AUTOFS_DEV_IOCTL_READY: u32 = 3222836086;
+pub const VIDIOC_ENUMAUDOUT: u32 = 3224655426;
+pub const VIDIOC_SUBDEV_S_STD: u32 = 1074288152;
+pub const WDIOC_GETTIMELEFT: u32 = 2147768074;
+pub const ATM_GETLINKRATE: u32 = 1074553217;
+pub const RTC_WKALM_SET: u32 = 1076391951;
+pub const VHOST_GET_BACKEND_FEATURES: u32 = 2148052774;
+pub const ATMARP_ENCAP: u32 = 25061;
+pub const CAPI_GET_FLAGS: u32 = 2147762979;
+pub const IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD: u32 = 2147772696;
+pub const DFL_FPGA_FME_PORT_ASSIGN: u32 = 1074050690;
+pub const NS_GET_OWNER_UID: u32 = 46852;
+pub const VIDIOC_OVERLAY: u32 = 1074025998;
+pub const BTRFS_IOC_WAIT_SYNC: u32 = 1074304022;
+pub const GPIOHANDLE_SET_CONFIG_IOCTL: u32 = 3226776586;
+pub const VHOST_GET_VRING_ENDIAN: u32 = 1074310932;
+pub const ATM_GETADDR: u32 = 1074553222;
+pub const PHN_GET_REGS: u32 = 3221516290;
+pub const AUTOFS_DEV_IOCTL_REQUESTER: u32 = 3222836091;
+pub const AUTOFS_DEV_IOCTL_EXPIRE: u32 = 3222836092;
+pub const SNAPSHOT_S2RAM: u32 = 13067;
+pub const JSIOCSAXMAP: u32 = 1077963313;
+pub const F2FS_IOC_SET_COMPRESS_OPTION: u32 = 1073935638;
+pub const VBG_IOCTL_HGCM_DISCONNECT: u32 = 3223082501;
+pub const SCIF_FENCE_SIGNAL: u32 = 3223614225;
+pub const VFIO_DEVICE_GET_PCI_HOT_RESET_INFO: u32 = 15216;
+pub const VIDIOC_SUBDEV_ENUM_MBUS_CODE: u32 = 3224393218;
+pub const MMTIMER_GETOFFSET: u32 = 27904;
+pub const RIO_CM_CHAN_LISTEN: u32 = 1073898246;
+pub const ATM_SETSC: u32 = 1074029041;
+pub const F2FS_IOC_SHUTDOWN: u32 = 2147768445;
+pub const NVME_IOCTL_RESCAN: u32 = 20038;
+pub const BLKOPENZONE: u32 = 1074795142;
+pub const DM_VERSION: u32 = 3241737472;
+pub const CEC_TRANSMIT: u32 = 3224920325;
+pub const FS_IOC_GET_ENCRYPTION_POLICY_EX: u32 = 3221841430;
+pub const SIOCMKCLIP: u32 = 25056;
+pub const IPMI_BMC_IOCTL_CLEAR_SMS_ATN: u32 = 45313;
+pub const HIDIOCGVERSION: u32 = 2147764225;
+pub const VIDIOC_S_INPUT: u32 = 3221509671;
+pub const VIDIOC_G_CROP: u32 = 3222558267;
+pub const LIRC_SET_WIDEBAND_RECEIVER: u32 = 1074030883;
+pub const EVIOCGEFFECTS: u32 = 2147763588;
+pub const UVCIOC_CTRL_QUERY: u32 = 3222041889;
+pub const IOC_OPAL_GENERIC_TABLE_RW: u32 = 1094217963;
+pub const FS_IOC_READ_VERITY_METADATA: u32 = 3223873159;
+pub const ND_IOCTL_SET_CONFIG_DATA: u32 = 3221769734;
+pub const USBDEVFS_GETDRIVER: u32 = 1090802952;
+pub const IDT77105_GETSTAT: u32 = 1074553138;
+pub const HIDIOCINITREPORT: u32 = 18437;
+pub const VFIO_DEVICE_GET_INFO: u32 = 15211;
+pub const RIO_CM_CHAN_RECEIVE: u32 = 3222299402;
+pub const RNDGETENTCNT: u32 = 2147766784;
+pub const PPPIOCNEWUNIT: u32 = 3221517374;
+pub const BTRFS_IOC_INO_LOOKUP: u32 = 3489698834;
+pub const FDRESET: u32 = 596;
+pub const IOC_PR_REGISTER: u32 = 1075343560;
+pub const HIDIOCSREPORT: u32 = 1074546696;
+pub const TEE_IOC_OPEN_SESSION: u32 = 2148574210;
+pub const TEE_IOC_SUPPL_RECV: u32 = 2148574214;
+pub const BTRFS_IOC_BALANCE_CTL: u32 = 1074041889;
+pub const GPIO_GET_LINEINFO_WATCH_IOCTL: u32 = 3225990155;
+pub const HIDIOCGRAWINFO: u32 = 2148026371;
+pub const PPPIOCSCOMPRESS: u32 = 1074558029;
+pub const USBDEVFS_CONNECTINFO: u32 = 1074287889;
+pub const BLKRESETZONE: u32 = 1074795139;
+pub const CHIOINITELEM: u32 = 25361;
+pub const NILFS_IOCTL_SET_ALLOC_RANGE: u32 = 1074818700;
+pub const AUTOFS_DEV_IOCTL_CATATONIC: u32 = 3222836089;
+pub const RIO_MPORT_MAINT_HDID_SET: u32 = 1073900801;
+pub const PPGETPHASE: u32 = 2147774617;
+pub const USBDEVFS_DISCONNECT_CLAIM: u32 = 2164806939;
+pub const FDMSGON: u32 = 581;
+pub const VIDIOC_G_SLICED_VBI_CAP: u32 = 3228849733;
+pub const BTRFS_IOC_BALANCE_V2: u32 = 3288372256;
+pub const MEDIA_REQUEST_IOC_REINIT: u32 = 31873;
+pub const IOC_OPAL_ERASE_LR: u32 = 1091596518;
+pub const FDFMTBEG: u32 = 583;
+pub const RNDRESEEDCRNG: u32 = 20999;
+pub const ISST_IF_GET_PHY_ID: u32 = 3221552641;
+pub const TUNSETNOCSUM: u32 = 1074025672;
+pub const SONET_GETSTAT: u32 = 2149867792;
+pub const TFD_IOC_SET_TICKS: u32 = 1074287616;
+pub const PPDATADIR: u32 = 1074032784;
+pub const IOC_OPAL_ENABLE_DISABLE_MBR: u32 = 1091596517;
+pub const GPIO_V2_GET_LINE_IOCTL: u32 = 3260068871;
+pub const RIO_CM_CHAN_SEND: u32 = 1074815753;
+pub const PPWCTLONIRQ: u32 = 1073836178;
+pub const SONYPI_IOCGBRT: u32 = 2147579392;
+pub const IOC_PR_RELEASE: u32 = 1074819274;
+pub const PPCLRIRQ: u32 = 2147774611;
+pub const IPMICTL_SET_MY_CHANNEL_LUN_CMD: u32 = 2147772698;
+pub const MGSL_IOCSXSYNC: u32 = 27923;
+pub const HPET_IE_OFF: u32 = 26626;
+pub const IOC_OPAL_ACTIVATE_USR: u32 = 1091596513;
+pub const SONET_SETFRAMING: u32 = 1074028821;
+pub const PERF_EVENT_IOC_PAUSE_OUTPUT: u32 = 1074013193;
+pub const BTRFS_IOC_LOGICAL_INO_V2: u32 = 3224933435;
+pub const VBG_IOCTL_HGCM_CONNECT: u32 = 3231471108;
+pub const BLKFINISHZONE: u32 = 1074795144;
+pub const EVIOCREVOKE: u32 = 1074021777;
+pub const VFIO_DEVICE_FEATURE: u32 = 15221;
+pub const CCISS_GETPCIINFO: u32 = 2148024833;
+pub const ISST_IF_MBOX_COMMAND: u32 = 3221552643;
+pub const SCIF_ACCEPTREQ: u32 = 3222303492;
+pub const PERF_EVENT_IOC_QUERY_BPF: u32 = 3221496842;
+pub const VIDIOC_STREAMOFF: u32 = 1074026003;
+pub const VDUSE_DESTROY_DEV: u32 = 1090552067;
+pub const FDGETFDCSTAT: u32 = 2149581333;
+pub const VIDIOC_S_PRIORITY: u32 = 1074026052;
+pub const SNAPSHOT_FREEZE: u32 = 13057;
+pub const VIDIOC_ENUMINPUT: u32 = 3226228250;
+pub const ZATM_GETPOOLZ: u32 = 1074553186;
+pub const RIO_DISABLE_DOORBELL_RANGE: u32 = 1074294026;
+pub const GPIO_V2_GET_LINEINFO_WATCH_IOCTL: u32 = 3238048774;
+pub const VIDIOC_G_STD: u32 = 2148029975;
+pub const USBDEVFS_ALLOW_SUSPEND: u32 = 21794;
+pub const SONET_GETSTATZ: u32 = 2149867793;
+pub const SCIF_ACCEPTREG: u32 = 3221779205;
+pub const VIDIOC_ENCODER_CMD: u32 = 3223869005;
+pub const PPPIOCSRASYNCMAP: u32 = 1074033748;
+pub const IOCTL_MEI_NOTIFY_SET: u32 = 1074022402;
+pub const BTRFS_IOC_QUOTA_RESCAN_STATUS: u32 = 2151715885;
+pub const F2FS_IOC_GARBAGE_COLLECT: u32 = 1074066694;
+pub const ATMLEC_CTRL: u32 = 25040;
+pub const MATROXFB_GET_AVAILABLE_OUTPUTS: u32 = 2147774201;
+pub const DM_DEV_CREATE: u32 = 3241737475;
+pub const VHOST_VDPA_GET_VRING_NUM: u32 = 2147659638;
+pub const VIDIOC_G_CTRL: u32 = 3221771803;
+pub const NBD_CLEAR_SOCK: u32 = 43780;
+pub const VFIO_DEVICE_QUERY_GFX_PLANE: u32 = 15218;
+pub const WDIOC_KEEPALIVE: u32 = 2147768069;
+pub const NVME_IOCTL_SUBSYS_RESET: u32 = 20037;
+pub const PTP_EXTTS_REQUEST2: u32 = 1074806027;
+pub const PCITEST_BAR: u32 = 20481;
+pub const MGSL_IOCGGPIO: u32 = 2148560145;
+pub const EVIOCSREP: u32 = 1074283779;
+pub const VFIO_DEVICE_GET_IRQ_INFO: u32 = 15213;
+pub const HPET_DPI: u32 = 26629;
+pub const VDUSE_VQ_SETUP_KICKFD: u32 = 1074299158;
+pub const ND_IOCTL_CALL: u32 = 3225439754;
+pub const HIDIOCGDEVINFO: u32 = 2149337091;
+pub const DM_TABLE_DEPS: u32 = 3241737483;
+pub const BTRFS_IOC_DEV_INFO: u32 = 3489698846;
+pub const VDUSE_IOTLB_GET_FD: u32 = 3223093520;
+pub const FW_CDEV_IOC_GET_INFO: u32 = 3223593728;
+pub const VIDIOC_G_PRIORITY: u32 = 2147767875;
+pub const ATM_NEWBACKENDIF: u32 = 1073897971;
+pub const VIDIOC_S_EXT_CTRLS: u32 = 3222820424;
+pub const VIDIOC_SUBDEV_ENUM_DV_TIMINGS: u32 = 3230946914;
+pub const VIDIOC_OMAP3ISP_CCDC_CFG: u32 = 3223344833;
+pub const VIDIOC_S_HW_FREQ_SEEK: u32 = 1076909650;
+pub const DM_TABLE_LOAD: u32 = 3241737481;
+pub const F2FS_IOC_START_ATOMIC_WRITE: u32 = 62721;
+pub const VIDIOC_G_OUTPUT: u32 = 2147767854;
+pub const ATM_DROPPARTY: u32 = 1074029045;
+pub const CHIOGELEM: u32 = 1080845072;
+pub const BTRFS_IOC_GET_SUPPORTED_FEATURES: u32 = 2152240185;
+pub const EVIOCSKEYCODE: u32 = 1074283780;
+pub const NE_GET_IMAGE_LOAD_INFO: u32 = 3222318626;
+pub const TUNSETLINK: u32 = 1074025677;
+pub const FW_CDEV_IOC_ADD_DESCRIPTOR: u32 = 3222807302;
+pub const BTRFS_IOC_SCRUB_CANCEL: u32 = 37916;
+pub const PPS_SETPARAMS: u32 = 1074032802;
+pub const IOC_OPAL_LR_SETUP: u32 = 1093169379;
+pub const FW_CDEV_IOC_DEALLOCATE: u32 = 1074012931;
+pub const WDIOC_SETTIMEOUT: u32 = 3221509894;
+pub const IOC_WATCH_QUEUE_SET_FILTER: u32 = 22369;
+pub const CAPI_GET_MANUFACTURER: u32 = 3221504774;
+pub const VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY: u32 = 15222;
+pub const ASPEED_P2A_CTRL_IOCTL_SET_WINDOW: u32 = 1074836224;
+pub const VIDIOC_G_EDID: u32 = 3223606824;
+pub const F2FS_IOC_GARBAGE_COLLECT_RANGE: u32 = 1075115275;
+pub const RIO_MAP_INBOUND: u32 = 3223874833;
+pub const IOC_OPAL_TAKE_OWNERSHIP: u32 = 1091072222;
+pub const USBDEVFS_CLAIM_PORT: u32 = 2147767576;
+pub const VIDIOC_S_AUDIO: u32 = 1077171746;
+pub const FS_IOC_GET_ENCRYPTION_NONCE: u32 = 2148558363;
+pub const FW_CDEV_IOC_SEND_STREAM_PACKET: u32 = 1076372243;
+pub const BTRFS_IOC_SNAP_DESTROY: u32 = 1342215183;
+pub const SNAPSHOT_FREE: u32 = 13061;
+pub const I8K_GET_SPEED: u32 = 3221514629;
+pub const HIDIOCGREPORT: u32 = 1074546695;
+pub const HPET_EPI: u32 = 26628;
+pub const JSIOCSCORR: u32 = 1076128289;
+pub const IOC_PR_PREEMPT_ABORT: u32 = 1075343564;
+pub const RIO_MAP_OUTBOUND: u32 = 3223874831;
+pub const ATM_SETESI: u32 = 1074553228;
+pub const FW_CDEV_IOC_START_ISO: u32 = 1074799370;
+pub const ATM_DELADDR: u32 = 1074553225;
+pub const PPFCONTROL: u32 = 1073901710;
+pub const SONYPI_IOCGFAN: u32 = 2147579402;
+pub const RTC_IRQP_SET: u32 = 1074032652;
+pub const PCITEST_WRITE: u32 = 1074024452;
+pub const PPCLAIM: u32 = 28811;
+pub const VIDIOC_S_JPEGCOMP: u32 = 1082938942;
+pub const IPMICTL_UNREGISTER_FOR_CMD: u32 = 2147641615;
+pub const VHOST_SET_FEATURES: u32 = 1074310912;
+pub const TOSHIBA_ACPI_SCI: u32 = 3222828177;
+pub const VIDIOC_DQBUF: u32 = 3225703953;
+pub const BTRFS_IOC_BALANCE_PROGRESS: u32 = 2214630434;
+pub const BTRFS_IOC_SUBVOL_SETFLAGS: u32 = 1074304026;
+pub const ATMLEC_MCAST: u32 = 25042;
+pub const MMTIMER_GETFREQ: u32 = 2147773698;
+pub const VIDIOC_G_SELECTION: u32 = 3225441886;
+pub const RTC_ALM_SET: u32 = 1076129799;
+pub const PPPOEIOCSFWD: u32 = 1074049280;
+pub const IPMICTL_GET_MAINTENANCE_MODE_CMD: u32 = 2147772702;
+pub const FS_IOC_ENABLE_VERITY: u32 = 1082156677;
+pub const NILFS_IOCTL_GET_BDESCS: u32 = 3222826631;
+pub const FDFMTEND: u32 = 585;
+pub const DMA_BUF_SET_NAME: u32 = 1074029057;
+pub const UI_BEGIN_FF_UPLOAD: u32 = 3227538888;
+pub const RTC_UIE_ON: u32 = 28675;
+pub const PPRELEASE: u32 = 28812;
+pub const VFIO_IOMMU_UNMAP_DMA: u32 = 15218;
+pub const VIDIOC_OMAP3ISP_PRV_CFG: u32 = 3225179842;
+pub const GPIO_GET_LINEHANDLE_IOCTL: u32 = 3245126659;
+pub const VFAT_IOCTL_READDIR_BOTH: u32 = 2182640129;
+pub const NVME_IOCTL_ADMIN_CMD: u32 = 3225964097;
+pub const VHOST_SET_VRING_KICK: u32 = 1074310944;
+pub const BTRFS_IOC_SUBVOL_CREATE_V2: u32 = 1342215192;
+pub const BTRFS_IOC_SNAP_CREATE: u32 = 1342215169;
+pub const SONYPI_IOCGBAT2CAP: u32 = 2147644932;
+pub const PPNEGOT: u32 = 1074032785;
+pub const NBD_PRINT_DEBUG: u32 = 43782;
+pub const BTRFS_IOC_INO_LOOKUP_USER: u32 = 3489698878;
+pub const BTRFS_IOC_GET_SUBVOL_ROOTREF: u32 = 3489698877;
+pub const FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: u32 = 3225445913;
+pub const BTRFS_IOC_FS_INFO: u32 = 2214630431;
+pub const VIDIOC_ENUM_FMT: u32 = 3225441794;
+pub const VIDIOC_G_INPUT: u32 = 2147767846;
+pub const VTPM_PROXY_IOC_NEW_DEV: u32 = 3222577408;
+pub const DFL_FPGA_FME_ERR_GET_IRQ_NUM: u32 = 2147792515;
+pub const ND_IOCTL_DIMM_FLAGS: u32 = 3221769731;
+pub const BTRFS_IOC_QUOTA_RESCAN: u32 = 1077974060;
+pub const MMTIMER_GETCOUNTER: u32 = 2147773705;
+pub const MATROXFB_GET_OUTPUT_MODE: u32 = 3221516026;
+pub const BTRFS_IOC_QUOTA_RESCAN_WAIT: u32 = 37934;
+pub const RIO_CM_CHAN_BIND: u32 = 1074291461;
+pub const HIDIOCGRDESC: u32 = 2416199682;
+pub const MGSL_IOCGIF: u32 = 27915;
+pub const VIDIOC_S_OUTPUT: u32 = 3221509679;
+pub const HIDIOCGREPORTINFO: u32 = 3222030345;
+pub const WDIOC_GETBOOTSTATUS: u32 = 2147768066;
+pub const VDUSE_VQ_GET_INFO: u32 = 3224142101;
+pub const ACRN_IOCTL_ASSIGN_PCIDEV: u32 = 1076142677;
+pub const BLKGETDISKSEQ: u32 = 2148012672;
+pub const ACRN_IOCTL_PM_GET_CPU_STATE: u32 = 3221791328;
+pub const ACRN_IOCTL_DESTROY_VM: u32 = 41489;
+pub const ACRN_IOCTL_SET_PTDEV_INTR: u32 = 1075094099;
+pub const ACRN_IOCTL_CREATE_IOREQ_CLIENT: u32 = 41522;
+pub const ACRN_IOCTL_IRQFD: u32 = 1075356273;
+pub const ACRN_IOCTL_CREATE_VM: u32 = 3224412688;
+pub const ACRN_IOCTL_INJECT_MSI: u32 = 1074831907;
+pub const ACRN_IOCTL_ATTACH_IOREQ_CLIENT: u32 = 41523;
+pub const ACRN_IOCTL_RESET_PTDEV_INTR: u32 = 1075094100;
+pub const ACRN_IOCTL_NOTIFY_REQUEST_FINISH: u32 = 1074307633;
+pub const ACRN_IOCTL_SET_IRQLINE: u32 = 1074307621;
+pub const ACRN_IOCTL_START_VM: u32 = 41490;
+pub const ACRN_IOCTL_SET_VCPU_REGS: u32 = 1092919830;
+pub const ACRN_IOCTL_SET_MEMSEG: u32 = 1075880513;
+pub const ACRN_IOCTL_PAUSE_VM: u32 = 41491;
+pub const ACRN_IOCTL_CLEAR_VM_IOREQ: u32 = 41525;
+pub const ACRN_IOCTL_UNSET_MEMSEG: u32 = 1075880514;
+pub const ACRN_IOCTL_IOEVENTFD: u32 = 1075880560;
+pub const ACRN_IOCTL_DEASSIGN_PCIDEV: u32 = 1076142678;
+pub const ACRN_IOCTL_RESET_VM: u32 = 41493;
+pub const ACRN_IOCTL_DESTROY_IOREQ_CLIENT: u32 = 41524;
+pub const ACRN_IOCTL_VM_INTR_MONITOR: u32 = 1074045476;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/landlock.rs

@@ -0,0 +1,102 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_ruleset_attr {
+pub handled_access_fs: __u64,
+pub handled_access_net: __u64,
+pub scoped: __u64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_path_beneath_attr {
+pub allowed_access: __u64,
+pub parent_fd: __s32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_net_port_attr {
+pub allowed_access: __u64,
+pub port: __u64,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const LANDLOCK_CREATE_RULESET_VERSION: u32 = 1;
+pub const LANDLOCK_CREATE_RULESET_ERRATA: u32 = 2;
+pub const LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF: u32 = 1;
+pub const LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON: u32 = 2;
+pub const LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF: u32 = 4;
+pub const LANDLOCK_ACCESS_FS_EXECUTE: u32 = 1;
+pub const LANDLOCK_ACCESS_FS_WRITE_FILE: u32 = 2;
+pub const LANDLOCK_ACCESS_FS_READ_FILE: u32 = 4;
+pub const LANDLOCK_ACCESS_FS_READ_DIR: u32 = 8;
+pub const LANDLOCK_ACCESS_FS_REMOVE_DIR: u32 = 16;
+pub const LANDLOCK_ACCESS_FS_REMOVE_FILE: u32 = 32;
+pub const LANDLOCK_ACCESS_FS_MAKE_CHAR: u32 = 64;
+pub const LANDLOCK_ACCESS_FS_MAKE_DIR: u32 = 128;
+pub const LANDLOCK_ACCESS_FS_MAKE_REG: u32 = 256;
+pub const LANDLOCK_ACCESS_FS_MAKE_SOCK: u32 = 512;
+pub const LANDLOCK_ACCESS_FS_MAKE_FIFO: u32 = 1024;
+pub const LANDLOCK_ACCESS_FS_MAKE_BLOCK: u32 = 2048;
+pub const LANDLOCK_ACCESS_FS_MAKE_SYM: u32 = 4096;
+pub const LANDLOCK_ACCESS_FS_REFER: u32 = 8192;
+pub const LANDLOCK_ACCESS_FS_TRUNCATE: u32 = 16384;
+pub const LANDLOCK_ACCESS_FS_IOCTL_DEV: u32 = 32768;
+pub const LANDLOCK_ACCESS_NET_BIND_TCP: u32 = 1;
+pub const LANDLOCK_ACCESS_NET_CONNECT_TCP: u32 = 2;
+pub const LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET: u32 = 1;
+pub const LANDLOCK_SCOPE_SIGNAL: u32 = 2;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum landlock_rule_type {
+LANDLOCK_RULE_PATH_BENEATH = 1,
+LANDLOCK_RULE_NET_PORT = 2,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/loop_device.rs

@@ -0,0 +1,132 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct loop_info {
+pub lo_number: crate::ctypes::c_int,
+pub lo_device: __kernel_old_dev_t,
+pub lo_inode: crate::ctypes::c_ulong,
+pub lo_rdevice: __kernel_old_dev_t,
+pub lo_offset: crate::ctypes::c_int,
+pub lo_encrypt_type: crate::ctypes::c_int,
+pub lo_encrypt_key_size: crate::ctypes::c_int,
+pub lo_flags: crate::ctypes::c_int,
+pub lo_name: [crate::ctypes::c_char; 64usize],
+pub lo_encrypt_key: [crate::ctypes::c_uchar; 32usize],
+pub lo_init: [crate::ctypes::c_ulong; 2usize],
+pub reserved: [crate::ctypes::c_char; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct loop_info64 {
+pub lo_device: __u64,
+pub lo_inode: __u64,
+pub lo_rdevice: __u64,
+pub lo_offset: __u64,
+pub lo_sizelimit: __u64,
+pub lo_number: __u32,
+pub lo_encrypt_type: __u32,
+pub lo_encrypt_key_size: __u32,
+pub lo_flags: __u32,
+pub lo_file_name: [__u8; 64usize],
+pub lo_crypt_name: [__u8; 64usize],
+pub lo_encrypt_key: [__u8; 32usize],
+pub lo_init: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct loop_config {
+pub fd: __u32,
+pub block_size: __u32,
+pub info: loop_info64,
+pub __reserved: [__u64; 8usize],
+}
+pub const LO_NAME_SIZE: u32 = 64;
+pub const LO_KEY_SIZE: u32 = 32;
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const LO_CRYPT_NONE: u32 = 0;
+pub const LO_CRYPT_XOR: u32 = 1;
+pub const LO_CRYPT_DES: u32 = 2;
+pub const LO_CRYPT_FISH2: u32 = 3;
+pub const LO_CRYPT_BLOW: u32 = 4;
+pub const LO_CRYPT_CAST128: u32 = 5;
+pub const LO_CRYPT_IDEA: u32 = 6;
+pub const LO_CRYPT_DUMMY: u32 = 9;
+pub const LO_CRYPT_SKIPJACK: u32 = 10;
+pub const LO_CRYPT_CRYPTOAPI: u32 = 18;
+pub const MAX_LO_CRYPT: u32 = 20;
+pub const LOOP_SET_FD: u32 = 19456;
+pub const LOOP_CLR_FD: u32 = 19457;
+pub const LOOP_SET_STATUS: u32 = 19458;
+pub const LOOP_GET_STATUS: u32 = 19459;
+pub const LOOP_SET_STATUS64: u32 = 19460;
+pub const LOOP_GET_STATUS64: u32 = 19461;
+pub const LOOP_CHANGE_FD: u32 = 19462;
+pub const LOOP_SET_CAPACITY: u32 = 19463;
+pub const LOOP_SET_DIRECT_IO: u32 = 19464;
+pub const LOOP_SET_BLOCK_SIZE: u32 = 19465;
+pub const LOOP_CONFIGURE: u32 = 19466;
+pub const LOOP_CTL_ADD: u32 = 19584;
+pub const LOOP_CTL_REMOVE: u32 = 19585;
+pub const LOOP_CTL_GET_FREE: u32 = 19586;
+pub const LO_FLAGS_READ_ONLY: _bindgen_ty_1 = _bindgen_ty_1::LO_FLAGS_READ_ONLY;
+pub const LO_FLAGS_AUTOCLEAR: _bindgen_ty_1 = _bindgen_ty_1::LO_FLAGS_AUTOCLEAR;
+pub const LO_FLAGS_PARTSCAN: _bindgen_ty_1 = _bindgen_ty_1::LO_FLAGS_PARTSCAN;
+pub const LO_FLAGS_DIRECT_IO: _bindgen_ty_1 = _bindgen_ty_1::LO_FLAGS_DIRECT_IO;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+LO_FLAGS_READ_ONLY = 1,
+LO_FLAGS_AUTOCLEAR = 4,
+LO_FLAGS_PARTSCAN = 8,
+LO_FLAGS_DIRECT_IO = 16,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/mempolicy.rs

@@ -0,0 +1,175 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const EPERM: u32 = 1;
+pub const ENOENT: u32 = 2;
+pub const ESRCH: u32 = 3;
+pub const EINTR: u32 = 4;
+pub const EIO: u32 = 5;
+pub const ENXIO: u32 = 6;
+pub const E2BIG: u32 = 7;
+pub const ENOEXEC: u32 = 8;
+pub const EBADF: u32 = 9;
+pub const ECHILD: u32 = 10;
+pub const EAGAIN: u32 = 11;
+pub const ENOMEM: u32 = 12;
+pub const EACCES: u32 = 13;
+pub const EFAULT: u32 = 14;
+pub const ENOTBLK: u32 = 15;
+pub const EBUSY: u32 = 16;
+pub const EEXIST: u32 = 17;
+pub const EXDEV: u32 = 18;
+pub const ENODEV: u32 = 19;
+pub const ENOTDIR: u32 = 20;
+pub const EISDIR: u32 = 21;
+pub const EINVAL: u32 = 22;
+pub const ENFILE: u32 = 23;
+pub const EMFILE: u32 = 24;
+pub const ENOTTY: u32 = 25;
+pub const ETXTBSY: u32 = 26;
+pub const EFBIG: u32 = 27;
+pub const ENOSPC: u32 = 28;
+pub const ESPIPE: u32 = 29;
+pub const EROFS: u32 = 30;
+pub const EMLINK: u32 = 31;
+pub const EPIPE: u32 = 32;
+pub const EDOM: u32 = 33;
+pub const ERANGE: u32 = 34;
+pub const EDEADLK: u32 = 35;
+pub const ENAMETOOLONG: u32 = 36;
+pub const ENOLCK: u32 = 37;
+pub const ENOSYS: u32 = 38;
+pub const ENOTEMPTY: u32 = 39;
+pub const ELOOP: u32 = 40;
+pub const EWOULDBLOCK: u32 = 11;
+pub const ENOMSG: u32 = 42;
+pub const EIDRM: u32 = 43;
+pub const ECHRNG: u32 = 44;
+pub const EL2NSYNC: u32 = 45;
+pub const EL3HLT: u32 = 46;
+pub const EL3RST: u32 = 47;
+pub const ELNRNG: u32 = 48;
+pub const EUNATCH: u32 = 49;
+pub const ENOCSI: u32 = 50;
+pub const EL2HLT: u32 = 51;
+pub const EBADE: u32 = 52;
+pub const EBADR: u32 = 53;
+pub const EXFULL: u32 = 54;
+pub const ENOANO: u32 = 55;
+pub const EBADRQC: u32 = 56;
+pub const EBADSLT: u32 = 57;
+pub const EDEADLOCK: u32 = 35;
+pub const EBFONT: u32 = 59;
+pub const ENOSTR: u32 = 60;
+pub const ENODATA: u32 = 61;
+pub const ETIME: u32 = 62;
+pub const ENOSR: u32 = 63;
+pub const ENONET: u32 = 64;
+pub const ENOPKG: u32 = 65;
+pub const EREMOTE: u32 = 66;
+pub const ENOLINK: u32 = 67;
+pub const EADV: u32 = 68;
+pub const ESRMNT: u32 = 69;
+pub const ECOMM: u32 = 70;
+pub const EPROTO: u32 = 71;
+pub const EMULTIHOP: u32 = 72;
+pub const EDOTDOT: u32 = 73;
+pub const EBADMSG: u32 = 74;
+pub const EOVERFLOW: u32 = 75;
+pub const ENOTUNIQ: u32 = 76;
+pub const EBADFD: u32 = 77;
+pub const EREMCHG: u32 = 78;
+pub const ELIBACC: u32 = 79;
+pub const ELIBBAD: u32 = 80;
+pub const ELIBSCN: u32 = 81;
+pub const ELIBMAX: u32 = 82;
+pub const ELIBEXEC: u32 = 83;
+pub const EILSEQ: u32 = 84;
+pub const ERESTART: u32 = 85;
+pub const ESTRPIPE: u32 = 86;
+pub const EUSERS: u32 = 87;
+pub const ENOTSOCK: u32 = 88;
+pub const EDESTADDRREQ: u32 = 89;
+pub const EMSGSIZE: u32 = 90;
+pub const EPROTOTYPE: u32 = 91;
+pub const ENOPROTOOPT: u32 = 92;
+pub const EPROTONOSUPPORT: u32 = 93;
+pub const ESOCKTNOSUPPORT: u32 = 94;
+pub const EOPNOTSUPP: u32 = 95;
+pub const EPFNOSUPPORT: u32 = 96;
+pub const EAFNOSUPPORT: u32 = 97;
+pub const EADDRINUSE: u32 = 98;
+pub const EADDRNOTAVAIL: u32 = 99;
+pub const ENETDOWN: u32 = 100;
+pub const ENETUNREACH: u32 = 101;
+pub const ENETRESET: u32 = 102;
+pub const ECONNABORTED: u32 = 103;
+pub const ECONNRESET: u32 = 104;
+pub const ENOBUFS: u32 = 105;
+pub const EISCONN: u32 = 106;
+pub const ENOTCONN: u32 = 107;
+pub const ESHUTDOWN: u32 = 108;
+pub const ETOOMANYREFS: u32 = 109;
+pub const ETIMEDOUT: u32 = 110;
+pub const ECONNREFUSED: u32 = 111;
+pub const EHOSTDOWN: u32 = 112;
+pub const EHOSTUNREACH: u32 = 113;
+pub const EALREADY: u32 = 114;
+pub const EINPROGRESS: u32 = 115;
+pub const ESTALE: u32 = 116;
+pub const EUCLEAN: u32 = 117;
+pub const ENOTNAM: u32 = 118;
+pub const ENAVAIL: u32 = 119;
+pub const EISNAM: u32 = 120;
+pub const EREMOTEIO: u32 = 121;
+pub const EDQUOT: u32 = 122;
+pub const ENOMEDIUM: u32 = 123;
+pub const EMEDIUMTYPE: u32 = 124;
+pub const ECANCELED: u32 = 125;
+pub const ENOKEY: u32 = 126;
+pub const EKEYEXPIRED: u32 = 127;
+pub const EKEYREVOKED: u32 = 128;
+pub const EKEYREJECTED: u32 = 129;
+pub const EOWNERDEAD: u32 = 130;
+pub const ENOTRECOVERABLE: u32 = 131;
+pub const ERFKILL: u32 = 132;
+pub const EHWPOISON: u32 = 133;
+pub const MPOL_F_STATIC_NODES: u32 = 32768;
+pub const MPOL_F_RELATIVE_NODES: u32 = 16384;
+pub const MPOL_F_NUMA_BALANCING: u32 = 8192;
+pub const MPOL_MODE_FLAGS: u32 = 57344;
+pub const MPOL_F_NODE: u32 = 1;
+pub const MPOL_F_ADDR: u32 = 2;
+pub const MPOL_F_MEMS_ALLOWED: u32 = 4;
+pub const MPOL_MF_STRICT: u32 = 1;
+pub const MPOL_MF_MOVE: u32 = 2;
+pub const MPOL_MF_MOVE_ALL: u32 = 4;
+pub const MPOL_MF_LAZY: u32 = 8;
+pub const MPOL_MF_INTERNAL: u32 = 16;
+pub const MPOL_MF_VALID: u32 = 7;
+pub const MPOL_F_SHARED: u32 = 1;
+pub const MPOL_F_MOF: u32 = 8;
+pub const MPOL_F_MORON: u32 = 16;
+pub const RECLAIM_ZONE: u32 = 1;
+pub const RECLAIM_WRITE: u32 = 2;
+pub const RECLAIM_UNMAP: u32 = 4;
+pub const MPOL_DEFAULT: _bindgen_ty_1 = _bindgen_ty_1::MPOL_DEFAULT;
+pub const MPOL_PREFERRED: _bindgen_ty_1 = _bindgen_ty_1::MPOL_PREFERRED;
+pub const MPOL_BIND: _bindgen_ty_1 = _bindgen_ty_1::MPOL_BIND;
+pub const MPOL_INTERLEAVE: _bindgen_ty_1 = _bindgen_ty_1::MPOL_INTERLEAVE;
+pub const MPOL_LOCAL: _bindgen_ty_1 = _bindgen_ty_1::MPOL_LOCAL;
+pub const MPOL_PREFERRED_MANY: _bindgen_ty_1 = _bindgen_ty_1::MPOL_PREFERRED_MANY;
+pub const MPOL_WEIGHTED_INTERLEAVE: _bindgen_ty_1 = _bindgen_ty_1::MPOL_WEIGHTED_INTERLEAVE;
+pub const MPOL_MAX: _bindgen_ty_1 = _bindgen_ty_1::MPOL_MAX;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+MPOL_DEFAULT = 0,
+MPOL_PREFERRED = 1,
+MPOL_BIND = 2,
+MPOL_INTERLEAVE = 3,
+MPOL_LOCAL = 4,
+MPOL_PREFERRED_MANY = 5,
+MPOL_WEIGHTED_INTERLEAVE = 6,
+MPOL_MAX = 7,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/prctl.rs

@@ -0,0 +1,269 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct prctl_mm_map {
+pub start_code: __u64,
+pub end_code: __u64,
+pub start_data: __u64,
+pub end_data: __u64,
+pub start_brk: __u64,
+pub brk: __u64,
+pub start_stack: __u64,
+pub arg_start: __u64,
+pub arg_end: __u64,
+pub env_start: __u64,
+pub env_end: __u64,
+pub auxv: *mut __u64,
+pub auxv_size: __u32,
+pub exe_fd: __u32,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const PR_SET_PDEATHSIG: u32 = 1;
+pub const PR_GET_PDEATHSIG: u32 = 2;
+pub const PR_GET_DUMPABLE: u32 = 3;
+pub const PR_SET_DUMPABLE: u32 = 4;
+pub const PR_GET_UNALIGN: u32 = 5;
+pub const PR_SET_UNALIGN: u32 = 6;
+pub const PR_UNALIGN_NOPRINT: u32 = 1;
+pub const PR_UNALIGN_SIGBUS: u32 = 2;
+pub const PR_GET_KEEPCAPS: u32 = 7;
+pub const PR_SET_KEEPCAPS: u32 = 8;
+pub const PR_GET_FPEMU: u32 = 9;
+pub const PR_SET_FPEMU: u32 = 10;
+pub const PR_FPEMU_NOPRINT: u32 = 1;
+pub const PR_FPEMU_SIGFPE: u32 = 2;
+pub const PR_GET_FPEXC: u32 = 11;
+pub const PR_SET_FPEXC: u32 = 12;
+pub const PR_FP_EXC_SW_ENABLE: u32 = 128;
+pub const PR_FP_EXC_DIV: u32 = 65536;
+pub const PR_FP_EXC_OVF: u32 = 131072;
+pub const PR_FP_EXC_UND: u32 = 262144;
+pub const PR_FP_EXC_RES: u32 = 524288;
+pub const PR_FP_EXC_INV: u32 = 1048576;
+pub const PR_FP_EXC_DISABLED: u32 = 0;
+pub const PR_FP_EXC_NONRECOV: u32 = 1;
+pub const PR_FP_EXC_ASYNC: u32 = 2;
+pub const PR_FP_EXC_PRECISE: u32 = 3;
+pub const PR_GET_TIMING: u32 = 13;
+pub const PR_SET_TIMING: u32 = 14;
+pub const PR_TIMING_STATISTICAL: u32 = 0;
+pub const PR_TIMING_TIMESTAMP: u32 = 1;
+pub const PR_SET_NAME: u32 = 15;
+pub const PR_GET_NAME: u32 = 16;
+pub const PR_GET_ENDIAN: u32 = 19;
+pub const PR_SET_ENDIAN: u32 = 20;
+pub const PR_ENDIAN_BIG: u32 = 0;
+pub const PR_ENDIAN_LITTLE: u32 = 1;
+pub const PR_ENDIAN_PPC_LITTLE: u32 = 2;
+pub const PR_GET_SECCOMP: u32 = 21;
+pub const PR_SET_SECCOMP: u32 = 22;
+pub const PR_CAPBSET_READ: u32 = 23;
+pub const PR_CAPBSET_DROP: u32 = 24;
+pub const PR_GET_TSC: u32 = 25;
+pub const PR_SET_TSC: u32 = 26;
+pub const PR_TSC_ENABLE: u32 = 1;
+pub const PR_TSC_SIGSEGV: u32 = 2;
+pub const PR_GET_SECUREBITS: u32 = 27;
+pub const PR_SET_SECUREBITS: u32 = 28;
+pub const PR_SET_TIMERSLACK: u32 = 29;
+pub const PR_GET_TIMERSLACK: u32 = 30;
+pub const PR_TASK_PERF_EVENTS_DISABLE: u32 = 31;
+pub const PR_TASK_PERF_EVENTS_ENABLE: u32 = 32;
+pub const PR_MCE_KILL: u32 = 33;
+pub const PR_MCE_KILL_CLEAR: u32 = 0;
+pub const PR_MCE_KILL_SET: u32 = 1;
+pub const PR_MCE_KILL_LATE: u32 = 0;
+pub const PR_MCE_KILL_EARLY: u32 = 1;
+pub const PR_MCE_KILL_DEFAULT: u32 = 2;
+pub const PR_MCE_KILL_GET: u32 = 34;
+pub const PR_SET_MM: u32 = 35;
+pub const PR_SET_MM_START_CODE: u32 = 1;
+pub const PR_SET_MM_END_CODE: u32 = 2;
+pub const PR_SET_MM_START_DATA: u32 = 3;
+pub const PR_SET_MM_END_DATA: u32 = 4;
+pub const PR_SET_MM_START_STACK: u32 = 5;
+pub const PR_SET_MM_START_BRK: u32 = 6;
+pub const PR_SET_MM_BRK: u32 = 7;
+pub const PR_SET_MM_ARG_START: u32 = 8;
+pub const PR_SET_MM_ARG_END: u32 = 9;
+pub const PR_SET_MM_ENV_START: u32 = 10;
+pub const PR_SET_MM_ENV_END: u32 = 11;
+pub const PR_SET_MM_AUXV: u32 = 12;
+pub const PR_SET_MM_EXE_FILE: u32 = 13;
+pub const PR_SET_MM_MAP: u32 = 14;
+pub const PR_SET_MM_MAP_SIZE: u32 = 15;
+pub const PR_SET_PTRACER: u32 = 1499557217;
+pub const PR_SET_CHILD_SUBREAPER: u32 = 36;
+pub const PR_GET_CHILD_SUBREAPER: u32 = 37;
+pub const PR_SET_NO_NEW_PRIVS: u32 = 38;
+pub const PR_GET_NO_NEW_PRIVS: u32 = 39;
+pub const PR_GET_TID_ADDRESS: u32 = 40;
+pub const PR_SET_THP_DISABLE: u32 = 41;
+pub const PR_GET_THP_DISABLE: u32 = 42;
+pub const PR_MPX_ENABLE_MANAGEMENT: u32 = 43;
+pub const PR_MPX_DISABLE_MANAGEMENT: u32 = 44;
+pub const PR_SET_FP_MODE: u32 = 45;
+pub const PR_GET_FP_MODE: u32 = 46;
+pub const PR_FP_MODE_FR: u32 = 1;
+pub const PR_FP_MODE_FRE: u32 = 2;
+pub const PR_CAP_AMBIENT: u32 = 47;
+pub const PR_CAP_AMBIENT_IS_SET: u32 = 1;
+pub const PR_CAP_AMBIENT_RAISE: u32 = 2;
+pub const PR_CAP_AMBIENT_LOWER: u32 = 3;
+pub const PR_CAP_AMBIENT_CLEAR_ALL: u32 = 4;
+pub const PR_SVE_SET_VL: u32 = 50;
+pub const PR_SVE_SET_VL_ONEXEC: u32 = 262144;
+pub const PR_SVE_GET_VL: u32 = 51;
+pub const PR_SVE_VL_LEN_MASK: u32 = 65535;
+pub const PR_SVE_VL_INHERIT: u32 = 131072;
+pub const PR_GET_SPECULATION_CTRL: u32 = 52;
+pub const PR_SET_SPECULATION_CTRL: u32 = 53;
+pub const PR_SPEC_STORE_BYPASS: u32 = 0;
+pub const PR_SPEC_INDIRECT_BRANCH: u32 = 1;
+pub const PR_SPEC_L1D_FLUSH: u32 = 2;
+pub const PR_SPEC_NOT_AFFECTED: u32 = 0;
+pub const PR_SPEC_PRCTL: u32 = 1;
+pub const PR_SPEC_ENABLE: u32 = 2;
+pub const PR_SPEC_DISABLE: u32 = 4;
+pub const PR_SPEC_FORCE_DISABLE: u32 = 8;
+pub const PR_SPEC_DISABLE_NOEXEC: u32 = 16;
+pub const PR_PAC_RESET_KEYS: u32 = 54;
+pub const PR_PAC_APIAKEY: u32 = 1;
+pub const PR_PAC_APIBKEY: u32 = 2;
+pub const PR_PAC_APDAKEY: u32 = 4;
+pub const PR_PAC_APDBKEY: u32 = 8;
+pub const PR_PAC_APGAKEY: u32 = 16;
+pub const PR_SET_TAGGED_ADDR_CTRL: u32 = 55;
+pub const PR_GET_TAGGED_ADDR_CTRL: u32 = 56;
+pub const PR_TAGGED_ADDR_ENABLE: u32 = 1;
+pub const PR_MTE_TCF_NONE: u32 = 0;
+pub const PR_MTE_TCF_SYNC: u32 = 2;
+pub const PR_MTE_TCF_ASYNC: u32 = 4;
+pub const PR_MTE_TCF_MASK: u32 = 6;
+pub const PR_MTE_TAG_SHIFT: u32 = 3;
+pub const PR_MTE_TAG_MASK: u32 = 524280;
+pub const PR_MTE_TCF_SHIFT: u32 = 1;
+pub const PR_PMLEN_SHIFT: u32 = 24;
+pub const PR_PMLEN_MASK: u32 = 2130706432;
+pub const PR_SET_IO_FLUSHER: u32 = 57;
+pub const PR_GET_IO_FLUSHER: u32 = 58;
+pub const PR_SET_SYSCALL_USER_DISPATCH: u32 = 59;
+pub const PR_SYS_DISPATCH_OFF: u32 = 0;
+pub const PR_SYS_DISPATCH_ON: u32 = 1;
+pub const SYSCALL_DISPATCH_FILTER_ALLOW: u32 = 0;
+pub const SYSCALL_DISPATCH_FILTER_BLOCK: u32 = 1;
+pub const PR_PAC_SET_ENABLED_KEYS: u32 = 60;
+pub const PR_PAC_GET_ENABLED_KEYS: u32 = 61;
+pub const PR_SCHED_CORE: u32 = 62;
+pub const PR_SCHED_CORE_GET: u32 = 0;
+pub const PR_SCHED_CORE_CREATE: u32 = 1;
+pub const PR_SCHED_CORE_SHARE_TO: u32 = 2;
+pub const PR_SCHED_CORE_SHARE_FROM: u32 = 3;
+pub const PR_SCHED_CORE_MAX: u32 = 4;
+pub const PR_SCHED_CORE_SCOPE_THREAD: u32 = 0;
+pub const PR_SCHED_CORE_SCOPE_THREAD_GROUP: u32 = 1;
+pub const PR_SCHED_CORE_SCOPE_PROCESS_GROUP: u32 = 2;
+pub const PR_SME_SET_VL: u32 = 63;
+pub const PR_SME_SET_VL_ONEXEC: u32 = 262144;
+pub const PR_SME_GET_VL: u32 = 64;
+pub const PR_SME_VL_LEN_MASK: u32 = 65535;
+pub const PR_SME_VL_INHERIT: u32 = 131072;
+pub const PR_SET_MDWE: u32 = 65;
+pub const PR_MDWE_REFUSE_EXEC_GAIN: u32 = 1;
+pub const PR_MDWE_NO_INHERIT: u32 = 2;
+pub const PR_GET_MDWE: u32 = 66;
+pub const PR_SET_VMA: u32 = 1398164801;
+pub const PR_SET_VMA_ANON_NAME: u32 = 0;
+pub const PR_GET_AUXV: u32 = 1096112214;
+pub const PR_SET_MEMORY_MERGE: u32 = 67;
+pub const PR_GET_MEMORY_MERGE: u32 = 68;
+pub const PR_RISCV_V_SET_CONTROL: u32 = 69;
+pub const PR_RISCV_V_GET_CONTROL: u32 = 70;
+pub const PR_RISCV_V_VSTATE_CTRL_DEFAULT: u32 = 0;
+pub const PR_RISCV_V_VSTATE_CTRL_OFF: u32 = 1;
+pub const PR_RISCV_V_VSTATE_CTRL_ON: u32 = 2;
+pub const PR_RISCV_V_VSTATE_CTRL_INHERIT: u32 = 16;
+pub const PR_RISCV_V_VSTATE_CTRL_CUR_MASK: u32 = 3;
+pub const PR_RISCV_V_VSTATE_CTRL_NEXT_MASK: u32 = 12;
+pub const PR_RISCV_V_VSTATE_CTRL_MASK: u32 = 31;
+pub const PR_RISCV_SET_ICACHE_FLUSH_CTX: u32 = 71;
+pub const PR_RISCV_CTX_SW_FENCEI_ON: u32 = 0;
+pub const PR_RISCV_CTX_SW_FENCEI_OFF: u32 = 1;
+pub const PR_RISCV_SCOPE_PER_PROCESS: u32 = 0;
+pub const PR_RISCV_SCOPE_PER_THREAD: u32 = 1;
+pub const PR_PPC_GET_DEXCR: u32 = 72;
+pub const PR_PPC_SET_DEXCR: u32 = 73;
+pub const PR_PPC_DEXCR_SBHE: u32 = 0;
+pub const PR_PPC_DEXCR_IBRTPD: u32 = 1;
+pub const PR_PPC_DEXCR_SRAPD: u32 = 2;
+pub const PR_PPC_DEXCR_NPHIE: u32 = 3;
+pub const PR_PPC_DEXCR_CTRL_EDITABLE: u32 = 1;
+pub const PR_PPC_DEXCR_CTRL_SET: u32 = 2;
+pub const PR_PPC_DEXCR_CTRL_CLEAR: u32 = 4;
+pub const PR_PPC_DEXCR_CTRL_SET_ONEXEC: u32 = 8;
+pub const PR_PPC_DEXCR_CTRL_CLEAR_ONEXEC: u32 = 16;
+pub const PR_PPC_DEXCR_CTRL_MASK: u32 = 31;
+pub const PR_GET_SHADOW_STACK_STATUS: u32 = 74;
+pub const PR_SET_SHADOW_STACK_STATUS: u32 = 75;
+pub const PR_SHADOW_STACK_ENABLE: u32 = 1;
+pub const PR_SHADOW_STACK_WRITE: u32 = 2;
+pub const PR_SHADOW_STACK_PUSH: u32 = 4;
+pub const PR_LOCK_SHADOW_STACK_STATUS: u32 = 76;
+pub const PR_TIMER_CREATE_RESTORE_IDS: u32 = 77;
+pub const PR_TIMER_CREATE_RESTORE_IDS_OFF: u32 = 0;
+pub const PR_TIMER_CREATE_RESTORE_IDS_ON: u32 = 1;
+pub const PR_TIMER_CREATE_RESTORE_IDS_GET: u32 = 2;
+pub const PR_FUTEX_HASH: u32 = 78;
+pub const PR_FUTEX_HASH_SET_SLOTS: u32 = 1;
+pub const FH_FLAG_IMMUTABLE: u32 = 1;
+pub const PR_FUTEX_HASH_GET_SLOTS: u32 = 2;
+pub const PR_FUTEX_HASH_GET_IMMUTABLE: u32 = 3;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/ptrace.rs

@@ -0,0 +1,814 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct audit_status {
+pub mask: __u32,
+pub enabled: __u32,
+pub failure: __u32,
+pub pid: __u32,
+pub rate_limit: __u32,
+pub backlog_limit: __u32,
+pub lost: __u32,
+pub backlog: __u32,
+pub __bindgen_anon_1: audit_status__bindgen_ty_1,
+pub backlog_wait_time: __u32,
+pub backlog_wait_time_actual: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct audit_features {
+pub vers: __u32,
+pub mask: __u32,
+pub features: __u32,
+pub lock: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct audit_tty_status {
+pub enabled: __u32,
+pub log_passwd: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct audit_rule_data {
+pub flags: __u32,
+pub action: __u32,
+pub field_count: __u32,
+pub mask: [__u32; 64usize],
+pub fields: [__u32; 64usize],
+pub values: [__u32; 64usize],
+pub fieldflags: [__u32; 64usize],
+pub buflen: __u32,
+pub buf: __IncompleteArrayField<crate::ctypes::c_char>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sock_filter {
+pub code: __u16,
+pub jt: __u8,
+pub jf: __u8,
+pub k: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sock_fprog {
+pub len: crate::ctypes::c_ushort,
+pub filter: *mut sock_filter,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_peeksiginfo_args {
+pub off: __u64,
+pub flags: __u32,
+pub nr: __s32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_metadata {
+pub filter_off: __u64,
+pub flags: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct ptrace_syscall_info {
+pub op: __u8,
+pub reserved: __u8,
+pub flags: __u16,
+pub arch: __u32,
+pub instruction_pointer: __u64,
+pub stack_pointer: __u64,
+pub __bindgen_anon_1: ptrace_syscall_info__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_syscall_info__bindgen_ty_1__bindgen_ty_1 {
+pub nr: __u64,
+pub args: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_syscall_info__bindgen_ty_1__bindgen_ty_2 {
+pub rval: __s64,
+pub is_error: __u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_syscall_info__bindgen_ty_1__bindgen_ty_3 {
+pub nr: __u64,
+pub args: [__u64; 6usize],
+pub ret_data: __u32,
+pub reserved2: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_rseq_configuration {
+pub rseq_abi_pointer: __u64,
+pub rseq_abi_size: __u32,
+pub signature: __u32,
+pub flags: __u32,
+pub pad: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct ptrace_sud_config {
+pub mode: __u64,
+pub selector: __u64,
+pub offset: __u64,
+pub len: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct pt_regs {
+pub tls: crate::ctypes::c_ulong,
+pub lr: crate::ctypes::c_ulong,
+pub pc: crate::ctypes::c_ulong,
+pub sr: crate::ctypes::c_ulong,
+pub usp: crate::ctypes::c_ulong,
+pub orig_a0: crate::ctypes::c_ulong,
+pub a0: crate::ctypes::c_ulong,
+pub a1: crate::ctypes::c_ulong,
+pub a2: crate::ctypes::c_ulong,
+pub a3: crate::ctypes::c_ulong,
+pub regs: [crate::ctypes::c_ulong; 10usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct user_fp {
+pub vr: [crate::ctypes::c_ulong; 96usize],
+pub fcr: crate::ctypes::c_ulong,
+pub fesr: crate::ctypes::c_ulong,
+pub fid: crate::ctypes::c_ulong,
+pub reserved: crate::ctypes::c_ulong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_data {
+pub nr: crate::ctypes::c_int,
+pub arch: __u32,
+pub instruction_pointer: __u64,
+pub args: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_notif_sizes {
+pub seccomp_notif: __u16,
+pub seccomp_notif_resp: __u16,
+pub seccomp_data: __u16,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_notif {
+pub id: __u64,
+pub pid: __u32,
+pub flags: __u32,
+pub data: seccomp_data,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_notif_resp {
+pub id: __u64,
+pub val: __s64,
+pub error: __s32,
+pub flags: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct seccomp_notif_addfd {
+pub id: __u64,
+pub flags: __u32,
+pub srcfd: __u32,
+pub newfd: __u32,
+pub newfd_flags: __u32,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const EM_NONE: u32 = 0;
+pub const EM_M32: u32 = 1;
+pub const EM_SPARC: u32 = 2;
+pub const EM_386: u32 = 3;
+pub const EM_68K: u32 = 4;
+pub const EM_88K: u32 = 5;
+pub const EM_486: u32 = 6;
+pub const EM_860: u32 = 7;
+pub const EM_MIPS: u32 = 8;
+pub const EM_MIPS_RS3_LE: u32 = 10;
+pub const EM_MIPS_RS4_BE: u32 = 10;
+pub const EM_PARISC: u32 = 15;
+pub const EM_SPARC32PLUS: u32 = 18;
+pub const EM_PPC: u32 = 20;
+pub const EM_PPC64: u32 = 21;
+pub const EM_SPU: u32 = 23;
+pub const EM_ARM: u32 = 40;
+pub const EM_SH: u32 = 42;
+pub const EM_SPARCV9: u32 = 43;
+pub const EM_H8_300: u32 = 46;
+pub const EM_IA_64: u32 = 50;
+pub const EM_X86_64: u32 = 62;
+pub const EM_S390: u32 = 22;
+pub const EM_CRIS: u32 = 76;
+pub const EM_M32R: u32 = 88;
+pub const EM_MN10300: u32 = 89;
+pub const EM_OPENRISC: u32 = 92;
+pub const EM_ARCOMPACT: u32 = 93;
+pub const EM_XTENSA: u32 = 94;
+pub const EM_BLACKFIN: u32 = 106;
+pub const EM_UNICORE: u32 = 110;
+pub const EM_ALTERA_NIOS2: u32 = 113;
+pub const EM_TI_C6000: u32 = 140;
+pub const EM_HEXAGON: u32 = 164;
+pub const EM_NDS32: u32 = 167;
+pub const EM_AARCH64: u32 = 183;
+pub const EM_TILEPRO: u32 = 188;
+pub const EM_MICROBLAZE: u32 = 189;
+pub const EM_TILEGX: u32 = 191;
+pub const EM_ARCV2: u32 = 195;
+pub const EM_RISCV: u32 = 243;
+pub const EM_BPF: u32 = 247;
+pub const EM_CSKY: u32 = 252;
+pub const EM_LOONGARCH: u32 = 258;
+pub const EM_FRV: u32 = 21569;
+pub const EM_ALPHA: u32 = 36902;
+pub const EM_CYGNUS_M32R: u32 = 36929;
+pub const EM_S390_OLD: u32 = 41872;
+pub const EM_CYGNUS_MN10300: u32 = 48879;
+pub const AUDIT_GET: u32 = 1000;
+pub const AUDIT_SET: u32 = 1001;
+pub const AUDIT_LIST: u32 = 1002;
+pub const AUDIT_ADD: u32 = 1003;
+pub const AUDIT_DEL: u32 = 1004;
+pub const AUDIT_USER: u32 = 1005;
+pub const AUDIT_LOGIN: u32 = 1006;
+pub const AUDIT_WATCH_INS: u32 = 1007;
+pub const AUDIT_WATCH_REM: u32 = 1008;
+pub const AUDIT_WATCH_LIST: u32 = 1009;
+pub const AUDIT_SIGNAL_INFO: u32 = 1010;
+pub const AUDIT_ADD_RULE: u32 = 1011;
+pub const AUDIT_DEL_RULE: u32 = 1012;
+pub const AUDIT_LIST_RULES: u32 = 1013;
+pub const AUDIT_TRIM: u32 = 1014;
+pub const AUDIT_MAKE_EQUIV: u32 = 1015;
+pub const AUDIT_TTY_GET: u32 = 1016;
+pub const AUDIT_TTY_SET: u32 = 1017;
+pub const AUDIT_SET_FEATURE: u32 = 1018;
+pub const AUDIT_GET_FEATURE: u32 = 1019;
+pub const AUDIT_FIRST_USER_MSG: u32 = 1100;
+pub const AUDIT_USER_AVC: u32 = 1107;
+pub const AUDIT_USER_TTY: u32 = 1124;
+pub const AUDIT_LAST_USER_MSG: u32 = 1199;
+pub const AUDIT_FIRST_USER_MSG2: u32 = 2100;
+pub const AUDIT_LAST_USER_MSG2: u32 = 2999;
+pub const AUDIT_DAEMON_START: u32 = 1200;
+pub const AUDIT_DAEMON_END: u32 = 1201;
+pub const AUDIT_DAEMON_ABORT: u32 = 1202;
+pub const AUDIT_DAEMON_CONFIG: u32 = 1203;
+pub const AUDIT_SYSCALL: u32 = 1300;
+pub const AUDIT_PATH: u32 = 1302;
+pub const AUDIT_IPC: u32 = 1303;
+pub const AUDIT_SOCKETCALL: u32 = 1304;
+pub const AUDIT_CONFIG_CHANGE: u32 = 1305;
+pub const AUDIT_SOCKADDR: u32 = 1306;
+pub const AUDIT_CWD: u32 = 1307;
+pub const AUDIT_EXECVE: u32 = 1309;
+pub const AUDIT_IPC_SET_PERM: u32 = 1311;
+pub const AUDIT_MQ_OPEN: u32 = 1312;
+pub const AUDIT_MQ_SENDRECV: u32 = 1313;
+pub const AUDIT_MQ_NOTIFY: u32 = 1314;
+pub const AUDIT_MQ_GETSETATTR: u32 = 1315;
+pub const AUDIT_KERNEL_OTHER: u32 = 1316;
+pub const AUDIT_FD_PAIR: u32 = 1317;
+pub const AUDIT_OBJ_PID: u32 = 1318;
+pub const AUDIT_TTY: u32 = 1319;
+pub const AUDIT_EOE: u32 = 1320;
+pub const AUDIT_BPRM_FCAPS: u32 = 1321;
+pub const AUDIT_CAPSET: u32 = 1322;
+pub const AUDIT_MMAP: u32 = 1323;
+pub const AUDIT_NETFILTER_PKT: u32 = 1324;
+pub const AUDIT_NETFILTER_CFG: u32 = 1325;
+pub const AUDIT_SECCOMP: u32 = 1326;
+pub const AUDIT_PROCTITLE: u32 = 1327;
+pub const AUDIT_FEATURE_CHANGE: u32 = 1328;
+pub const AUDIT_REPLACE: u32 = 1329;
+pub const AUDIT_KERN_MODULE: u32 = 1330;
+pub const AUDIT_FANOTIFY: u32 = 1331;
+pub const AUDIT_TIME_INJOFFSET: u32 = 1332;
+pub const AUDIT_TIME_ADJNTPVAL: u32 = 1333;
+pub const AUDIT_BPF: u32 = 1334;
+pub const AUDIT_EVENT_LISTENER: u32 = 1335;
+pub const AUDIT_URINGOP: u32 = 1336;
+pub const AUDIT_OPENAT2: u32 = 1337;
+pub const AUDIT_DM_CTRL: u32 = 1338;
+pub const AUDIT_DM_EVENT: u32 = 1339;
+pub const AUDIT_AVC: u32 = 1400;
+pub const AUDIT_SELINUX_ERR: u32 = 1401;
+pub const AUDIT_AVC_PATH: u32 = 1402;
+pub const AUDIT_MAC_POLICY_LOAD: u32 = 1403;
+pub const AUDIT_MAC_STATUS: u32 = 1404;
+pub const AUDIT_MAC_CONFIG_CHANGE: u32 = 1405;
+pub const AUDIT_MAC_UNLBL_ALLOW: u32 = 1406;
+pub const AUDIT_MAC_CIPSOV4_ADD: u32 = 1407;
+pub const AUDIT_MAC_CIPSOV4_DEL: u32 = 1408;
+pub const AUDIT_MAC_MAP_ADD: u32 = 1409;
+pub const AUDIT_MAC_MAP_DEL: u32 = 1410;
+pub const AUDIT_MAC_IPSEC_ADDSA: u32 = 1411;
+pub const AUDIT_MAC_IPSEC_DELSA: u32 = 1412;
+pub const AUDIT_MAC_IPSEC_ADDSPD: u32 = 1413;
+pub const AUDIT_MAC_IPSEC_DELSPD: u32 = 1414;
+pub const AUDIT_MAC_IPSEC_EVENT: u32 = 1415;
+pub const AUDIT_MAC_UNLBL_STCADD: u32 = 1416;
+pub const AUDIT_MAC_UNLBL_STCDEL: u32 = 1417;
+pub const AUDIT_MAC_CALIPSO_ADD: u32 = 1418;
+pub const AUDIT_MAC_CALIPSO_DEL: u32 = 1419;
+pub const AUDIT_IPE_ACCESS: u32 = 1420;
+pub const AUDIT_IPE_CONFIG_CHANGE: u32 = 1421;
+pub const AUDIT_IPE_POLICY_LOAD: u32 = 1422;
+pub const AUDIT_LANDLOCK_ACCESS: u32 = 1423;
+pub const AUDIT_LANDLOCK_DOMAIN: u32 = 1424;
+pub const AUDIT_FIRST_KERN_ANOM_MSG: u32 = 1700;
+pub const AUDIT_LAST_KERN_ANOM_MSG: u32 = 1799;
+pub const AUDIT_ANOM_PROMISCUOUS: u32 = 1700;
+pub const AUDIT_ANOM_ABEND: u32 = 1701;
+pub const AUDIT_ANOM_LINK: u32 = 1702;
+pub const AUDIT_ANOM_CREAT: u32 = 1703;
+pub const AUDIT_INTEGRITY_DATA: u32 = 1800;
+pub const AUDIT_INTEGRITY_METADATA: u32 = 1801;
+pub const AUDIT_INTEGRITY_STATUS: u32 = 1802;
+pub const AUDIT_INTEGRITY_HASH: u32 = 1803;
+pub const AUDIT_INTEGRITY_PCR: u32 = 1804;
+pub const AUDIT_INTEGRITY_RULE: u32 = 1805;
+pub const AUDIT_INTEGRITY_EVM_XATTR: u32 = 1806;
+pub const AUDIT_INTEGRITY_POLICY_RULE: u32 = 1807;
+pub const AUDIT_INTEGRITY_USERSPACE: u32 = 1808;
+pub const AUDIT_KERNEL: u32 = 2000;
+pub const AUDIT_FILTER_USER: u32 = 0;
+pub const AUDIT_FILTER_TASK: u32 = 1;
+pub const AUDIT_FILTER_ENTRY: u32 = 2;
+pub const AUDIT_FILTER_WATCH: u32 = 3;
+pub const AUDIT_FILTER_EXIT: u32 = 4;
+pub const AUDIT_FILTER_EXCLUDE: u32 = 5;
+pub const AUDIT_FILTER_TYPE: u32 = 5;
+pub const AUDIT_FILTER_FS: u32 = 6;
+pub const AUDIT_FILTER_URING_EXIT: u32 = 7;
+pub const AUDIT_NR_FILTERS: u32 = 8;
+pub const AUDIT_FILTER_PREPEND: u32 = 16;
+pub const AUDIT_NEVER: u32 = 0;
+pub const AUDIT_POSSIBLE: u32 = 1;
+pub const AUDIT_ALWAYS: u32 = 2;
+pub const AUDIT_MAX_FIELDS: u32 = 64;
+pub const AUDIT_MAX_KEY_LEN: u32 = 256;
+pub const AUDIT_BITMASK_SIZE: u32 = 64;
+pub const AUDIT_SYSCALL_CLASSES: u32 = 16;
+pub const AUDIT_CLASS_DIR_WRITE: u32 = 0;
+pub const AUDIT_CLASS_DIR_WRITE_32: u32 = 1;
+pub const AUDIT_CLASS_CHATTR: u32 = 2;
+pub const AUDIT_CLASS_CHATTR_32: u32 = 3;
+pub const AUDIT_CLASS_READ: u32 = 4;
+pub const AUDIT_CLASS_READ_32: u32 = 5;
+pub const AUDIT_CLASS_WRITE: u32 = 6;
+pub const AUDIT_CLASS_WRITE_32: u32 = 7;
+pub const AUDIT_CLASS_SIGNAL: u32 = 8;
+pub const AUDIT_CLASS_SIGNAL_32: u32 = 9;
+pub const AUDIT_UNUSED_BITS: u32 = 134216704;
+pub const AUDIT_COMPARE_UID_TO_OBJ_UID: u32 = 1;
+pub const AUDIT_COMPARE_GID_TO_OBJ_GID: u32 = 2;
+pub const AUDIT_COMPARE_EUID_TO_OBJ_UID: u32 = 3;
+pub const AUDIT_COMPARE_EGID_TO_OBJ_GID: u32 = 4;
+pub const AUDIT_COMPARE_AUID_TO_OBJ_UID: u32 = 5;
+pub const AUDIT_COMPARE_SUID_TO_OBJ_UID: u32 = 6;
+pub const AUDIT_COMPARE_SGID_TO_OBJ_GID: u32 = 7;
+pub const AUDIT_COMPARE_FSUID_TO_OBJ_UID: u32 = 8;
+pub const AUDIT_COMPARE_FSGID_TO_OBJ_GID: u32 = 9;
+pub const AUDIT_COMPARE_UID_TO_AUID: u32 = 10;
+pub const AUDIT_COMPARE_UID_TO_EUID: u32 = 11;
+pub const AUDIT_COMPARE_UID_TO_FSUID: u32 = 12;
+pub const AUDIT_COMPARE_UID_TO_SUID: u32 = 13;
+pub const AUDIT_COMPARE_AUID_TO_FSUID: u32 = 14;
+pub const AUDIT_COMPARE_AUID_TO_SUID: u32 = 15;
+pub const AUDIT_COMPARE_AUID_TO_EUID: u32 = 16;
+pub const AUDIT_COMPARE_EUID_TO_SUID: u32 = 17;
+pub const AUDIT_COMPARE_EUID_TO_FSUID: u32 = 18;
+pub const AUDIT_COMPARE_SUID_TO_FSUID: u32 = 19;
+pub const AUDIT_COMPARE_GID_TO_EGID: u32 = 20;
+pub const AUDIT_COMPARE_GID_TO_FSGID: u32 = 21;
+pub const AUDIT_COMPARE_GID_TO_SGID: u32 = 22;
+pub const AUDIT_COMPARE_EGID_TO_FSGID: u32 = 23;
+pub const AUDIT_COMPARE_EGID_TO_SGID: u32 = 24;
+pub const AUDIT_COMPARE_SGID_TO_FSGID: u32 = 25;
+pub const AUDIT_MAX_FIELD_COMPARE: u32 = 25;
+pub const AUDIT_PID: u32 = 0;
+pub const AUDIT_UID: u32 = 1;
+pub const AUDIT_EUID: u32 = 2;
+pub const AUDIT_SUID: u32 = 3;
+pub const AUDIT_FSUID: u32 = 4;
+pub const AUDIT_GID: u32 = 5;
+pub const AUDIT_EGID: u32 = 6;
+pub const AUDIT_SGID: u32 = 7;
+pub const AUDIT_FSGID: u32 = 8;
+pub const AUDIT_LOGINUID: u32 = 9;
+pub const AUDIT_PERS: u32 = 10;
+pub const AUDIT_ARCH: u32 = 11;
+pub const AUDIT_MSGTYPE: u32 = 12;
+pub const AUDIT_SUBJ_USER: u32 = 13;
+pub const AUDIT_SUBJ_ROLE: u32 = 14;
+pub const AUDIT_SUBJ_TYPE: u32 = 15;
+pub const AUDIT_SUBJ_SEN: u32 = 16;
+pub const AUDIT_SUBJ_CLR: u32 = 17;
+pub const AUDIT_PPID: u32 = 18;
+pub const AUDIT_OBJ_USER: u32 = 19;
+pub const AUDIT_OBJ_ROLE: u32 = 20;
+pub const AUDIT_OBJ_TYPE: u32 = 21;
+pub const AUDIT_OBJ_LEV_LOW: u32 = 22;
+pub const AUDIT_OBJ_LEV_HIGH: u32 = 23;
+pub const AUDIT_LOGINUID_SET: u32 = 24;
+pub const AUDIT_SESSIONID: u32 = 25;
+pub const AUDIT_FSTYPE: u32 = 26;
+pub const AUDIT_DEVMAJOR: u32 = 100;
+pub const AUDIT_DEVMINOR: u32 = 101;
+pub const AUDIT_INODE: u32 = 102;
+pub const AUDIT_EXIT: u32 = 103;
+pub const AUDIT_SUCCESS: u32 = 104;
+pub const AUDIT_WATCH: u32 = 105;
+pub const AUDIT_PERM: u32 = 106;
+pub const AUDIT_DIR: u32 = 107;
+pub const AUDIT_FILETYPE: u32 = 108;
+pub const AUDIT_OBJ_UID: u32 = 109;
+pub const AUDIT_OBJ_GID: u32 = 110;
+pub const AUDIT_FIELD_COMPARE: u32 = 111;
+pub const AUDIT_EXE: u32 = 112;
+pub const AUDIT_SADDR_FAM: u32 = 113;
+pub const AUDIT_ARG0: u32 = 200;
+pub const AUDIT_ARG1: u32 = 201;
+pub const AUDIT_ARG2: u32 = 202;
+pub const AUDIT_ARG3: u32 = 203;
+pub const AUDIT_FILTERKEY: u32 = 210;
+pub const AUDIT_NEGATE: u32 = 2147483648;
+pub const AUDIT_BIT_MASK: u32 = 134217728;
+pub const AUDIT_LESS_THAN: u32 = 268435456;
+pub const AUDIT_GREATER_THAN: u32 = 536870912;
+pub const AUDIT_NOT_EQUAL: u32 = 805306368;
+pub const AUDIT_EQUAL: u32 = 1073741824;
+pub const AUDIT_BIT_TEST: u32 = 1207959552;
+pub const AUDIT_LESS_THAN_OR_EQUAL: u32 = 1342177280;
+pub const AUDIT_GREATER_THAN_OR_EQUAL: u32 = 1610612736;
+pub const AUDIT_OPERATORS: u32 = 2013265920;
+pub const AUDIT_STATUS_ENABLED: u32 = 1;
+pub const AUDIT_STATUS_FAILURE: u32 = 2;
+pub const AUDIT_STATUS_PID: u32 = 4;
+pub const AUDIT_STATUS_RATE_LIMIT: u32 = 8;
+pub const AUDIT_STATUS_BACKLOG_LIMIT: u32 = 16;
+pub const AUDIT_STATUS_BACKLOG_WAIT_TIME: u32 = 32;
+pub const AUDIT_STATUS_LOST: u32 = 64;
+pub const AUDIT_STATUS_BACKLOG_WAIT_TIME_ACTUAL: u32 = 128;
+pub const AUDIT_FEATURE_BITMAP_BACKLOG_LIMIT: u32 = 1;
+pub const AUDIT_FEATURE_BITMAP_BACKLOG_WAIT_TIME: u32 = 2;
+pub const AUDIT_FEATURE_BITMAP_EXECUTABLE_PATH: u32 = 4;
+pub const AUDIT_FEATURE_BITMAP_EXCLUDE_EXTEND: u32 = 8;
+pub const AUDIT_FEATURE_BITMAP_SESSIONID_FILTER: u32 = 16;
+pub const AUDIT_FEATURE_BITMAP_LOST_RESET: u32 = 32;
+pub const AUDIT_FEATURE_BITMAP_FILTER_FS: u32 = 64;
+pub const AUDIT_FEATURE_BITMAP_ALL: u32 = 127;
+pub const AUDIT_VERSION_LATEST: u32 = 127;
+pub const AUDIT_VERSION_BACKLOG_LIMIT: u32 = 1;
+pub const AUDIT_VERSION_BACKLOG_WAIT_TIME: u32 = 2;
+pub const AUDIT_FAIL_SILENT: u32 = 0;
+pub const AUDIT_FAIL_PRINTK: u32 = 1;
+pub const AUDIT_FAIL_PANIC: u32 = 2;
+pub const __AUDIT_ARCH_CONVENTION_MASK: u32 = 805306368;
+pub const __AUDIT_ARCH_CONVENTION_MIPS64_N32: u32 = 536870912;
+pub const __AUDIT_ARCH_64BIT: u32 = 2147483648;
+pub const __AUDIT_ARCH_LE: u32 = 1073741824;
+pub const AUDIT_ARCH_AARCH64: u32 = 3221225655;
+pub const AUDIT_ARCH_ALPHA: u32 = 3221262374;
+pub const AUDIT_ARCH_ARCOMPACT: u32 = 1073741917;
+pub const AUDIT_ARCH_ARCOMPACTBE: u32 = 93;
+pub const AUDIT_ARCH_ARCV2: u32 = 1073742019;
+pub const AUDIT_ARCH_ARCV2BE: u32 = 195;
+pub const AUDIT_ARCH_ARM: u32 = 1073741864;
+pub const AUDIT_ARCH_ARMEB: u32 = 40;
+pub const AUDIT_ARCH_C6X: u32 = 1073741964;
+pub const AUDIT_ARCH_C6XBE: u32 = 140;
+pub const AUDIT_ARCH_CRIS: u32 = 1073741900;
+pub const AUDIT_ARCH_CSKY: u32 = 1073742076;
+pub const AUDIT_ARCH_FRV: u32 = 21569;
+pub const AUDIT_ARCH_H8300: u32 = 46;
+pub const AUDIT_ARCH_HEXAGON: u32 = 164;
+pub const AUDIT_ARCH_I386: u32 = 1073741827;
+pub const AUDIT_ARCH_IA64: u32 = 3221225522;
+pub const AUDIT_ARCH_M32R: u32 = 88;
+pub const AUDIT_ARCH_M68K: u32 = 4;
+pub const AUDIT_ARCH_MICROBLAZE: u32 = 189;
+pub const AUDIT_ARCH_MIPS: u32 = 8;
+pub const AUDIT_ARCH_MIPSEL: u32 = 1073741832;
+pub const AUDIT_ARCH_MIPS64: u32 = 2147483656;
+pub const AUDIT_ARCH_MIPS64N32: u32 = 2684354568;
+pub const AUDIT_ARCH_MIPSEL64: u32 = 3221225480;
+pub const AUDIT_ARCH_MIPSEL64N32: u32 = 3758096392;
+pub const AUDIT_ARCH_NDS32: u32 = 1073741991;
+pub const AUDIT_ARCH_NDS32BE: u32 = 167;
+pub const AUDIT_ARCH_NIOS2: u32 = 1073741937;
+pub const AUDIT_ARCH_OPENRISC: u32 = 92;
+pub const AUDIT_ARCH_PARISC: u32 = 15;
+pub const AUDIT_ARCH_PARISC64: u32 = 2147483663;
+pub const AUDIT_ARCH_PPC: u32 = 20;
+pub const AUDIT_ARCH_PPC64: u32 = 2147483669;
+pub const AUDIT_ARCH_PPC64LE: u32 = 3221225493;
+pub const AUDIT_ARCH_RISCV32: u32 = 1073742067;
+pub const AUDIT_ARCH_RISCV64: u32 = 3221225715;
+pub const AUDIT_ARCH_S390: u32 = 22;
+pub const AUDIT_ARCH_S390X: u32 = 2147483670;
+pub const AUDIT_ARCH_SH: u32 = 42;
+pub const AUDIT_ARCH_SHEL: u32 = 1073741866;
+pub const AUDIT_ARCH_SH64: u32 = 2147483690;
+pub const AUDIT_ARCH_SHEL64: u32 = 3221225514;
+pub const AUDIT_ARCH_SPARC: u32 = 2;
+pub const AUDIT_ARCH_SPARC64: u32 = 2147483691;
+pub const AUDIT_ARCH_TILEGX: u32 = 3221225663;
+pub const AUDIT_ARCH_TILEGX32: u32 = 1073742015;
+pub const AUDIT_ARCH_TILEPRO: u32 = 1073742012;
+pub const AUDIT_ARCH_UNICORE: u32 = 1073741934;
+pub const AUDIT_ARCH_X86_64: u32 = 3221225534;
+pub const AUDIT_ARCH_XTENSA: u32 = 94;
+pub const AUDIT_ARCH_LOONGARCH32: u32 = 1073742082;
+pub const AUDIT_ARCH_LOONGARCH64: u32 = 3221225730;
+pub const AUDIT_PERM_EXEC: u32 = 1;
+pub const AUDIT_PERM_WRITE: u32 = 2;
+pub const AUDIT_PERM_READ: u32 = 4;
+pub const AUDIT_PERM_ATTR: u32 = 8;
+pub const AUDIT_MESSAGE_TEXT_MAX: u32 = 8560;
+pub const AUDIT_FEATURE_VERSION: u32 = 1;
+pub const AUDIT_FEATURE_ONLY_UNSET_LOGINUID: u32 = 0;
+pub const AUDIT_FEATURE_LOGINUID_IMMUTABLE: u32 = 1;
+pub const AUDIT_LAST_FEATURE: u32 = 1;
+pub const BPF_LD: u32 = 0;
+pub const BPF_LDX: u32 = 1;
+pub const BPF_ST: u32 = 2;
+pub const BPF_STX: u32 = 3;
+pub const BPF_ALU: u32 = 4;
+pub const BPF_JMP: u32 = 5;
+pub const BPF_RET: u32 = 6;
+pub const BPF_MISC: u32 = 7;
+pub const BPF_W: u32 = 0;
+pub const BPF_H: u32 = 8;
+pub const BPF_B: u32 = 16;
+pub const BPF_IMM: u32 = 0;
+pub const BPF_ABS: u32 = 32;
+pub const BPF_IND: u32 = 64;
+pub const BPF_MEM: u32 = 96;
+pub const BPF_LEN: u32 = 128;
+pub const BPF_MSH: u32 = 160;
+pub const BPF_ADD: u32 = 0;
+pub const BPF_SUB: u32 = 16;
+pub const BPF_MUL: u32 = 32;
+pub const BPF_DIV: u32 = 48;
+pub const BPF_OR: u32 = 64;
+pub const BPF_AND: u32 = 80;
+pub const BPF_LSH: u32 = 96;
+pub const BPF_RSH: u32 = 112;
+pub const BPF_NEG: u32 = 128;
+pub const BPF_MOD: u32 = 144;
+pub const BPF_XOR: u32 = 160;
+pub const BPF_JA: u32 = 0;
+pub const BPF_JEQ: u32 = 16;
+pub const BPF_JGT: u32 = 32;
+pub const BPF_JGE: u32 = 48;
+pub const BPF_JSET: u32 = 64;
+pub const BPF_K: u32 = 0;
+pub const BPF_X: u32 = 8;
+pub const BPF_MAXINSNS: u32 = 4096;
+pub const BPF_MAJOR_VERSION: u32 = 1;
+pub const BPF_MINOR_VERSION: u32 = 1;
+pub const BPF_A: u32 = 16;
+pub const BPF_TAX: u32 = 0;
+pub const BPF_TXA: u32 = 128;
+pub const BPF_MEMWORDS: u32 = 16;
+pub const SKF_AD_OFF: i32 = -4096;
+pub const SKF_AD_PROTOCOL: u32 = 0;
+pub const SKF_AD_PKTTYPE: u32 = 4;
+pub const SKF_AD_IFINDEX: u32 = 8;
+pub const SKF_AD_NLATTR: u32 = 12;
+pub const SKF_AD_NLATTR_NEST: u32 = 16;
+pub const SKF_AD_MARK: u32 = 20;
+pub const SKF_AD_QUEUE: u32 = 24;
+pub const SKF_AD_HATYPE: u32 = 28;
+pub const SKF_AD_RXHASH: u32 = 32;
+pub const SKF_AD_CPU: u32 = 36;
+pub const SKF_AD_ALU_XOR_X: u32 = 40;
+pub const SKF_AD_VLAN_TAG: u32 = 44;
+pub const SKF_AD_VLAN_TAG_PRESENT: u32 = 48;
+pub const SKF_AD_PAY_OFFSET: u32 = 52;
+pub const SKF_AD_RANDOM: u32 = 56;
+pub const SKF_AD_VLAN_TPID: u32 = 60;
+pub const SKF_AD_MAX: u32 = 64;
+pub const SKF_NET_OFF: i32 = -1048576;
+pub const SKF_LL_OFF: i32 = -2097152;
+pub const BPF_NET_OFF: i32 = -1048576;
+pub const BPF_LL_OFF: i32 = -2097152;
+pub const PTRACE_TRACEME: u32 = 0;
+pub const PTRACE_PEEKTEXT: u32 = 1;
+pub const PTRACE_PEEKDATA: u32 = 2;
+pub const PTRACE_PEEKUSR: u32 = 3;
+pub const PTRACE_POKETEXT: u32 = 4;
+pub const PTRACE_POKEDATA: u32 = 5;
+pub const PTRACE_POKEUSR: u32 = 6;
+pub const PTRACE_CONT: u32 = 7;
+pub const PTRACE_KILL: u32 = 8;
+pub const PTRACE_SINGLESTEP: u32 = 9;
+pub const PTRACE_ATTACH: u32 = 16;
+pub const PTRACE_DETACH: u32 = 17;
+pub const PTRACE_SYSCALL: u32 = 24;
+pub const PTRACE_SETOPTIONS: u32 = 16896;
+pub const PTRACE_GETEVENTMSG: u32 = 16897;
+pub const PTRACE_GETSIGINFO: u32 = 16898;
+pub const PTRACE_SETSIGINFO: u32 = 16899;
+pub const PTRACE_GETREGSET: u32 = 16900;
+pub const PTRACE_SETREGSET: u32 = 16901;
+pub const PTRACE_SEIZE: u32 = 16902;
+pub const PTRACE_INTERRUPT: u32 = 16903;
+pub const PTRACE_LISTEN: u32 = 16904;
+pub const PTRACE_PEEKSIGINFO: u32 = 16905;
+pub const PTRACE_GETSIGMASK: u32 = 16906;
+pub const PTRACE_SETSIGMASK: u32 = 16907;
+pub const PTRACE_SECCOMP_GET_FILTER: u32 = 16908;
+pub const PTRACE_SECCOMP_GET_METADATA: u32 = 16909;
+pub const PTRACE_GET_SYSCALL_INFO: u32 = 16910;
+pub const PTRACE_SET_SYSCALL_INFO: u32 = 16914;
+pub const PTRACE_SYSCALL_INFO_NONE: u32 = 0;
+pub const PTRACE_SYSCALL_INFO_ENTRY: u32 = 1;
+pub const PTRACE_SYSCALL_INFO_EXIT: u32 = 2;
+pub const PTRACE_SYSCALL_INFO_SECCOMP: u32 = 3;
+pub const PTRACE_GET_RSEQ_CONFIGURATION: u32 = 16911;
+pub const PTRACE_SET_SYSCALL_USER_DISPATCH_CONFIG: u32 = 16912;
+pub const PTRACE_GET_SYSCALL_USER_DISPATCH_CONFIG: u32 = 16913;
+pub const PTRACE_EVENTMSG_SYSCALL_ENTRY: u32 = 1;
+pub const PTRACE_EVENTMSG_SYSCALL_EXIT: u32 = 2;
+pub const PTRACE_PEEKSIGINFO_SHARED: u32 = 1;
+pub const PTRACE_EVENT_FORK: u32 = 1;
+pub const PTRACE_EVENT_VFORK: u32 = 2;
+pub const PTRACE_EVENT_CLONE: u32 = 3;
+pub const PTRACE_EVENT_EXEC: u32 = 4;
+pub const PTRACE_EVENT_VFORK_DONE: u32 = 5;
+pub const PTRACE_EVENT_EXIT: u32 = 6;
+pub const PTRACE_EVENT_SECCOMP: u32 = 7;
+pub const PTRACE_EVENT_STOP: u32 = 128;
+pub const PTRACE_O_TRACESYSGOOD: u32 = 1;
+pub const PTRACE_O_TRACEFORK: u32 = 2;
+pub const PTRACE_O_TRACEVFORK: u32 = 4;
+pub const PTRACE_O_TRACECLONE: u32 = 8;
+pub const PTRACE_O_TRACEEXEC: u32 = 16;
+pub const PTRACE_O_TRACEVFORKDONE: u32 = 32;
+pub const PTRACE_O_TRACEEXIT: u32 = 64;
+pub const PTRACE_O_TRACESECCOMP: u32 = 128;
+pub const PTRACE_O_EXITKILL: u32 = 1048576;
+pub const PTRACE_O_SUSPEND_SECCOMP: u32 = 2097152;
+pub const PTRACE_O_MASK: u32 = 3145983;
+pub const SECCOMP_MODE_DISABLED: u32 = 0;
+pub const SECCOMP_MODE_STRICT: u32 = 1;
+pub const SECCOMP_MODE_FILTER: u32 = 2;
+pub const SECCOMP_SET_MODE_STRICT: u32 = 0;
+pub const SECCOMP_SET_MODE_FILTER: u32 = 1;
+pub const SECCOMP_GET_ACTION_AVAIL: u32 = 2;
+pub const SECCOMP_GET_NOTIF_SIZES: u32 = 3;
+pub const SECCOMP_FILTER_FLAG_TSYNC: u32 = 1;
+pub const SECCOMP_FILTER_FLAG_LOG: u32 = 2;
+pub const SECCOMP_FILTER_FLAG_SPEC_ALLOW: u32 = 4;
+pub const SECCOMP_FILTER_FLAG_NEW_LISTENER: u32 = 8;
+pub const SECCOMP_FILTER_FLAG_TSYNC_ESRCH: u32 = 16;
+pub const SECCOMP_FILTER_FLAG_WAIT_KILLABLE_RECV: u32 = 32;
+pub const SECCOMP_RET_KILL_PROCESS: u32 = 2147483648;
+pub const SECCOMP_RET_KILL_THREAD: u32 = 0;
+pub const SECCOMP_RET_KILL: u32 = 0;
+pub const SECCOMP_RET_TRAP: u32 = 196608;
+pub const SECCOMP_RET_ERRNO: u32 = 327680;
+pub const SECCOMP_RET_USER_NOTIF: u32 = 2143289344;
+pub const SECCOMP_RET_TRACE: u32 = 2146435072;
+pub const SECCOMP_RET_LOG: u32 = 2147221504;
+pub const SECCOMP_RET_ALLOW: u32 = 2147418112;
+pub const SECCOMP_RET_ACTION_FULL: u32 = 4294901760;
+pub const SECCOMP_RET_ACTION: u32 = 2147418112;
+pub const SECCOMP_RET_DATA: u32 = 65535;
+pub const SECCOMP_USER_NOTIF_FLAG_CONTINUE: u32 = 1;
+pub const SECCOMP_USER_NOTIF_FD_SYNC_WAKE_UP: u32 = 1;
+pub const SECCOMP_ADDFD_FLAG_SETFD: u32 = 1;
+pub const SECCOMP_ADDFD_FLAG_SEND: u32 = 2;
+pub const SECCOMP_IOC_MAGIC: u8 = 33u8;
+pub const Audit_equal: _bindgen_ty_1 = _bindgen_ty_1::Audit_equal;
+pub const Audit_not_equal: _bindgen_ty_1 = _bindgen_ty_1::Audit_not_equal;
+pub const Audit_bitmask: _bindgen_ty_1 = _bindgen_ty_1::Audit_bitmask;
+pub const Audit_bittest: _bindgen_ty_1 = _bindgen_ty_1::Audit_bittest;
+pub const Audit_lt: _bindgen_ty_1 = _bindgen_ty_1::Audit_lt;
+pub const Audit_gt: _bindgen_ty_1 = _bindgen_ty_1::Audit_gt;
+pub const Audit_le: _bindgen_ty_1 = _bindgen_ty_1::Audit_le;
+pub const Audit_ge: _bindgen_ty_1 = _bindgen_ty_1::Audit_ge;
+pub const Audit_bad: _bindgen_ty_1 = _bindgen_ty_1::Audit_bad;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+Audit_equal = 0,
+Audit_not_equal = 1,
+Audit_bitmask = 2,
+Audit_bittest = 3,
+Audit_lt = 4,
+Audit_gt = 5,
+Audit_le = 6,
+Audit_ge = 7,
+Audit_bad = 8,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum audit_nlgrps {
+AUDIT_NLGRP_NONE = 0,
+AUDIT_NLGRP_READLOG = 1,
+__AUDIT_NLGRP_MAX = 2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union audit_status__bindgen_ty_1 {
+pub version: __u32,
+pub feature_bitmap: __u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union ptrace_syscall_info__bindgen_ty_1 {
+pub entry: ptrace_syscall_info__bindgen_ty_1__bindgen_ty_1,
+pub exit: ptrace_syscall_info__bindgen_ty_1__bindgen_ty_2,
+pub seccomp: ptrace_syscall_info__bindgen_ty_1__bindgen_ty_3,
+}
+impl<T> __IncompleteArrayField<T> {
+#[inline]
+pub const fn new() -> Self {
+__IncompleteArrayField(::core::marker::PhantomData, [])
+}
+#[inline]
+pub fn as_ptr(&self) -> *const T {
+self as *const _ as *const T
+}
+#[inline]
+pub fn as_mut_ptr(&mut self) -> *mut T {
+self as *mut _ as *mut T
+}
+#[inline]
+pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+::core::slice::from_raw_parts(self.as_ptr(), len)
+}
+#[inline]
+pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+}
+}
+impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__IncompleteArrayField")
+}
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/system.rs

@@ -0,0 +1,100 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sysinfo {
+pub uptime: __kernel_long_t,
+pub loads: [__kernel_ulong_t; 3usize],
+pub totalram: __kernel_ulong_t,
+pub freeram: __kernel_ulong_t,
+pub sharedram: __kernel_ulong_t,
+pub bufferram: __kernel_ulong_t,
+pub totalswap: __kernel_ulong_t,
+pub freeswap: __kernel_ulong_t,
+pub procs: __u16,
+pub pad: __u16,
+pub totalhigh: __kernel_ulong_t,
+pub freehigh: __kernel_ulong_t,
+pub mem_unit: __u32,
+pub _f: [crate::ctypes::c_char; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct oldold_utsname {
+pub sysname: [crate::ctypes::c_char; 9usize],
+pub nodename: [crate::ctypes::c_char; 9usize],
+pub release: [crate::ctypes::c_char; 9usize],
+pub version: [crate::ctypes::c_char; 9usize],
+pub machine: [crate::ctypes::c_char; 9usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct old_utsname {
+pub sysname: [crate::ctypes::c_char; 65usize],
+pub nodename: [crate::ctypes::c_char; 65usize],
+pub release: [crate::ctypes::c_char; 65usize],
+pub version: [crate::ctypes::c_char; 65usize],
+pub machine: [crate::ctypes::c_char; 65usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct new_utsname {
+pub sysname: [crate::ctypes::c_char; 65usize],
+pub nodename: [crate::ctypes::c_char; 65usize],
+pub release: [crate::ctypes::c_char; 65usize],
+pub version: [crate::ctypes::c_char; 65usize],
+pub machine: [crate::ctypes::c_char; 65usize],
+pub domainname: [crate::ctypes::c_char; 65usize],
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const SI_LOAD_SHIFT: u32 = 16;
+pub const __OLD_UTS_LEN: u32 = 8;
+pub const __NEW_UTS_LEN: u32 = 64;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/csky/xdp.rs

@@ -0,0 +1,191 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = crate::ctypes::c_uint;
+pub type __kernel_ssize_t = crate::ctypes::c_int;
+pub type __kernel_ptrdiff_t = crate::ctypes::c_int;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_xdp {
+pub sxdp_family: __u16,
+pub sxdp_flags: __u16,
+pub sxdp_ifindex: __u32,
+pub sxdp_queue_id: __u32,
+pub sxdp_shared_umem_fd: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_ring_offset {
+pub producer: __u64,
+pub consumer: __u64,
+pub desc: __u64,
+pub flags: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_mmap_offsets {
+pub rx: xdp_ring_offset,
+pub tx: xdp_ring_offset,
+pub fr: xdp_ring_offset,
+pub cr: xdp_ring_offset,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_umem_reg {
+pub addr: __u64,
+pub len: __u64,
+pub chunk_size: __u32,
+pub headroom: __u32,
+pub flags: __u32,
+pub tx_metadata_len: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_statistics {
+pub rx_dropped: __u64,
+pub rx_invalid_descs: __u64,
+pub tx_invalid_descs: __u64,
+pub rx_ring_full: __u64,
+pub rx_fill_ring_empty_descs: __u64,
+pub tx_ring_empty_descs: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_options {
+pub flags: __u32,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct xsk_tx_metadata {
+pub flags: __u64,
+pub __bindgen_anon_1: xsk_tx_metadata__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xsk_tx_metadata__bindgen_ty_1__bindgen_ty_1 {
+pub csum_start: __u16,
+pub csum_offset: __u16,
+pub launch_time: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xsk_tx_metadata__bindgen_ty_1__bindgen_ty_2 {
+pub tx_timestamp: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_desc {
+pub addr: __u64,
+pub len: __u32,
+pub options: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_ring_offset_v1 {
+pub producer: __u64,
+pub consumer: __u64,
+pub desc: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_mmap_offsets_v1 {
+pub rx: xdp_ring_offset_v1,
+pub tx: xdp_ring_offset_v1,
+pub fr: xdp_ring_offset_v1,
+pub cr: xdp_ring_offset_v1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_umem_reg_v1 {
+pub addr: __u64,
+pub len: __u64,
+pub chunk_size: __u32,
+pub headroom: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct xdp_statistics_v1 {
+pub rx_dropped: __u64,
+pub rx_invalid_descs: __u64,
+pub tx_invalid_descs: __u64,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const XDP_SHARED_UMEM: u32 = 1;
+pub const XDP_COPY: u32 = 2;
+pub const XDP_ZEROCOPY: u32 = 4;
+pub const XDP_USE_NEED_WAKEUP: u32 = 8;
+pub const XDP_USE_SG: u32 = 16;
+pub const XDP_UMEM_UNALIGNED_CHUNK_FLAG: u32 = 1;
+pub const XDP_UMEM_TX_SW_CSUM: u32 = 2;
+pub const XDP_UMEM_TX_METADATA_LEN: u32 = 4;
+pub const XDP_RING_NEED_WAKEUP: u32 = 1;
+pub const XDP_MMAP_OFFSETS: u32 = 1;
+pub const XDP_RX_RING: u32 = 2;
+pub const XDP_TX_RING: u32 = 3;
+pub const XDP_UMEM_REG: u32 = 4;
+pub const XDP_UMEM_FILL_RING: u32 = 5;
+pub const XDP_UMEM_COMPLETION_RING: u32 = 6;
+pub const XDP_STATISTICS: u32 = 7;
+pub const XDP_OPTIONS: u32 = 8;
+pub const XDP_OPTIONS_ZEROCOPY: u32 = 1;
+pub const XDP_PGOFF_RX_RING: u32 = 0;
+pub const XDP_PGOFF_TX_RING: u32 = 2147483648;
+pub const XDP_UMEM_PGOFF_FILL_RING: u64 = 4294967296;
+pub const XDP_UMEM_PGOFF_COMPLETION_RING: u64 = 6442450944;
+pub const XSK_UNALIGNED_BUF_OFFSET_SHIFT: u32 = 48;
+pub const XSK_UNALIGNED_BUF_ADDR_MASK: u64 = 281474976710655;
+pub const XDP_TXMD_FLAGS_TIMESTAMP: u32 = 1;
+pub const XDP_TXMD_FLAGS_CHECKSUM: u32 = 2;
+pub const XDP_TXMD_FLAGS_LAUNCH_TIME: u32 = 4;
+pub const XDP_PKT_CONTD: u32 = 1;
+pub const XDP_TX_METADATA: u32 = 2;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union xsk_tx_metadata__bindgen_ty_1 {
+pub request: xsk_tx_metadata__bindgen_ty_1__bindgen_ty_1,
+pub completion: xsk_tx_metadata__bindgen_ty_1__bindgen_ty_2,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/auxvec.rs

@@ -0,0 +1,32 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const AT_SYSINFO_EHDR: u32 = 33;
+pub const AT_VECTOR_SIZE_ARCH: u32 = 1;
+pub const AT_NULL: u32 = 0;
+pub const AT_IGNORE: u32 = 1;
+pub const AT_EXECFD: u32 = 2;
+pub const AT_PHDR: u32 = 3;
+pub const AT_PHENT: u32 = 4;
+pub const AT_PHNUM: u32 = 5;
+pub const AT_PAGESZ: u32 = 6;
+pub const AT_BASE: u32 = 7;
+pub const AT_FLAGS: u32 = 8;
+pub const AT_ENTRY: u32 = 9;
+pub const AT_NOTELF: u32 = 10;
+pub const AT_UID: u32 = 11;
+pub const AT_EUID: u32 = 12;
+pub const AT_GID: u32 = 13;
+pub const AT_EGID: u32 = 14;
+pub const AT_PLATFORM: u32 = 15;
+pub const AT_HWCAP: u32 = 16;
+pub const AT_CLKTCK: u32 = 17;
+pub const AT_SECURE: u32 = 23;
+pub const AT_BASE_PLATFORM: u32 = 24;
+pub const AT_RANDOM: u32 = 25;
+pub const AT_HWCAP2: u32 = 26;
+pub const AT_RSEQ_FEATURE_SIZE: u32 = 27;
+pub const AT_RSEQ_ALIGN: u32 = 28;
+pub const AT_HWCAP3: u32 = 29;
+pub const AT_HWCAP4: u32 = 30;
+pub const AT_EXECFN: u32 = 31;
+pub const AT_MINSIGSTKSZ: u32 = 51;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/bootparam.rs

@@ -0,0 +1,3 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/btrfs.rs

@@ -0,0 +1,1896 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type __kernel_rwf_t = crate::ctypes::c_int;
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v1 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub master_key_descriptor: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_key {
+pub mode: __u32,
+pub raw: [__u8; 64usize],
+pub size: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v2 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub log2_data_unit_size: __u8,
+pub __reserved: [__u8; 3usize],
+pub master_key_identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_policy_ex_arg {
+pub policy_size: __u64,
+pub policy: fscrypt_get_policy_ex_arg__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_key_specifier {
+pub type_: __u32,
+pub __reserved: __u32,
+pub u: fscrypt_key_specifier__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct fscrypt_provisioning_key_payload {
+pub type_: __u32,
+pub flags: __u32,
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+pub struct fscrypt_add_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub raw_size: __u32,
+pub key_id: __u32,
+pub flags: __u32,
+pub __reserved: [__u32; 7usize],
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_remove_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub removal_status_flags: __u32,
+pub __reserved: [__u32; 5usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_key_status_arg {
+pub key_spec: fscrypt_key_specifier,
+pub __reserved: [__u32; 6usize],
+pub status: __u32,
+pub status_flags: __u32,
+pub user_count: __u32,
+pub __out_reserved: [__u32; 13usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mount_attr {
+pub attr_set: __u64,
+pub attr_clr: __u64,
+pub propagation: __u64,
+pub userns_fd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct statmount {
+pub size: __u32,
+pub mnt_opts: __u32,
+pub mask: __u64,
+pub sb_dev_major: __u32,
+pub sb_dev_minor: __u32,
+pub sb_magic: __u64,
+pub sb_flags: __u32,
+pub fs_type: __u32,
+pub mnt_id: __u64,
+pub mnt_parent_id: __u64,
+pub mnt_id_old: __u32,
+pub mnt_parent_id_old: __u32,
+pub mnt_attr: __u64,
+pub mnt_propagation: __u64,
+pub mnt_peer_group: __u64,
+pub mnt_master: __u64,
+pub propagate_from: __u64,
+pub mnt_root: __u32,
+pub mnt_point: __u32,
+pub mnt_ns_id: __u64,
+pub fs_subtype: __u32,
+pub sb_source: __u32,
+pub opt_num: __u32,
+pub opt_array: __u32,
+pub opt_sec_num: __u32,
+pub opt_sec_array: __u32,
+pub supported_mask: __u64,
+pub mnt_uidmap_num: __u32,
+pub mnt_uidmap: __u32,
+pub mnt_gidmap_num: __u32,
+pub mnt_gidmap: __u32,
+pub __spare2: [__u64; 43usize],
+pub str_: __IncompleteArrayField<crate::ctypes::c_char>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mnt_id_req {
+pub size: __u32,
+pub spare: __u32,
+pub mnt_id: __u64,
+pub param: __u64,
+pub mnt_ns_id: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_clone_range {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fstrim_range {
+pub start: __u64,
+pub len: __u64,
+pub minlen: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsuuid2 {
+pub len: __u8,
+pub uuid: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fs_sysfs_path {
+pub len: __u8,
+pub name: [__u8; 128usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_dedupe_range_info {
+pub dest_fd: __s64,
+pub dest_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct file_dedupe_range {
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<file_dedupe_range_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct files_stat_struct {
+pub nr_files: crate::ctypes::c_ulong,
+pub nr_free_files: crate::ctypes::c_ulong,
+pub max_files: crate::ctypes::c_ulong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct inodes_stat_t {
+pub nr_inodes: crate::ctypes::c_long,
+pub nr_unused: crate::ctypes::c_long,
+pub dummy: [crate::ctypes::c_long; 5usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsxattr {
+pub fsx_xflags: __u32,
+pub fsx_extsize: __u32,
+pub fsx_nextents: __u32,
+pub fsx_projid: __u32,
+pub fsx_cowextsize: __u32,
+pub fsx_pad: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct page_region {
+pub start: __u64,
+pub end: __u64,
+pub categories: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct pm_scan_arg {
+pub size: __u64,
+pub flags: __u64,
+pub start: __u64,
+pub end: __u64,
+pub walk_end: __u64,
+pub vec: __u64,
+pub vec_len: __u64,
+pub max_pages: __u64,
+pub category_inverted: __u64,
+pub category_mask: __u64,
+pub category_anyof_mask: __u64,
+pub return_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct procmap_query {
+pub size: __u64,
+pub query_flags: __u64,
+pub query_addr: __u64,
+pub vma_start: __u64,
+pub vma_end: __u64,
+pub vma_flags: __u64,
+pub vma_page_size: __u64,
+pub vma_offset: __u64,
+pub inode: __u64,
+pub dev_major: __u32,
+pub dev_minor: __u32,
+pub vma_name_size: __u32,
+pub build_id_size: __u32,
+pub vma_name_addr: __u64,
+pub build_id_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_vol_args {
+pub fd: __s64,
+pub name: [crate::ctypes::c_char; 4088usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_limit {
+pub flags: __u64,
+pub max_rfer: __u64,
+pub max_excl: __u64,
+pub rsv_rfer: __u64,
+pub rsv_excl: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_qgroup_inherit {
+pub flags: __u64,
+pub num_qgroups: __u64,
+pub num_ref_copies: __u64,
+pub num_excl_copies: __u64,
+pub lim: btrfs_qgroup_limit,
+pub qgroups: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_limit_args {
+pub qgroupid: __u64,
+pub lim: btrfs_qgroup_limit,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_vol_args_v2 {
+pub fd: __s64,
+pub transid: __u64,
+pub flags: __u64,
+pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1,
+pub __bindgen_anon_2: btrfs_ioctl_vol_args_v2__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1 {
+pub size: __u64,
+pub qgroup_inherit: *mut btrfs_qgroup_inherit,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_scrub_progress {
+pub data_extents_scrubbed: __u64,
+pub tree_extents_scrubbed: __u64,
+pub data_bytes_scrubbed: __u64,
+pub tree_bytes_scrubbed: __u64,
+pub read_errors: __u64,
+pub csum_errors: __u64,
+pub verify_errors: __u64,
+pub no_csum: __u64,
+pub csum_discards: __u64,
+pub super_errors: __u64,
+pub malloc_errors: __u64,
+pub uncorrectable_errors: __u64,
+pub corrected_errors: __u64,
+pub last_physical: __u64,
+pub unverified_errors: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_scrub_args {
+pub devid: __u64,
+pub start: __u64,
+pub end: __u64,
+pub flags: __u64,
+pub progress: btrfs_scrub_progress,
+pub unused: [__u64; 109usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_start_params {
+pub srcdevid: __u64,
+pub cont_reading_from_srcdev_mode: __u64,
+pub srcdev_name: [__u8; 1025usize],
+pub tgtdev_name: [__u8; 1025usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_status_params {
+pub replace_state: __u64,
+pub progress_1000: __u64,
+pub time_started: __u64,
+pub time_stopped: __u64,
+pub num_write_errors: __u64,
+pub num_uncorrectable_read_errors: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_dev_replace_args {
+pub cmd: __u64,
+pub result: __u64,
+pub __bindgen_anon_1: btrfs_ioctl_dev_replace_args__bindgen_ty_1,
+pub spare: [__u64; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_dev_info_args {
+pub devid: __u64,
+pub uuid: [__u8; 16usize],
+pub bytes_used: __u64,
+pub total_bytes: __u64,
+pub fsid: [__u8; 16usize],
+pub unused: [__u64; 377usize],
+pub path: [__u8; 1024usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_fs_info_args {
+pub max_id: __u64,
+pub num_devices: __u64,
+pub fsid: [__u8; 16usize],
+pub nodesize: __u32,
+pub sectorsize: __u32,
+pub clone_alignment: __u32,
+pub csum_type: __u16,
+pub csum_size: __u16,
+pub flags: __u64,
+pub generation: __u64,
+pub metadata_uuid: [__u8; 16usize],
+pub reserved: [__u8; 944usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_feature_flags {
+pub compat_flags: __u64,
+pub compat_ro_flags: __u64,
+pub incompat_flags: __u64,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_balance_args {
+pub profiles: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1,
+pub devid: __u64,
+pub pstart: __u64,
+pub pend: __u64,
+pub vstart: __u64,
+pub vend: __u64,
+pub target: __u64,
+pub flags: __u64,
+pub __bindgen_anon_2: btrfs_balance_args__bindgen_ty_2,
+pub stripes_min: __u32,
+pub stripes_max: __u32,
+pub unused: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_args__bindgen_ty_1__bindgen_ty_1 {
+pub usage_min: __u32,
+pub usage_max: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_args__bindgen_ty_2__bindgen_ty_1 {
+pub limit_min: __u32,
+pub limit_max: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_balance_progress {
+pub expected: __u64,
+pub considered: __u64,
+pub completed: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_balance_args {
+pub flags: __u64,
+pub state: __u64,
+pub data: btrfs_balance_args,
+pub meta: btrfs_balance_args,
+pub sys: btrfs_balance_args,
+pub stat: btrfs_balance_progress,
+pub unused: [__u64; 72usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_lookup_args {
+pub treeid: __u64,
+pub objectid: __u64,
+pub name: [crate::ctypes::c_char; 4080usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_lookup_user_args {
+pub dirid: __u64,
+pub treeid: __u64,
+pub name: [crate::ctypes::c_char; 256usize],
+pub path: [crate::ctypes::c_char; 3824usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_key {
+pub tree_id: __u64,
+pub min_objectid: __u64,
+pub max_objectid: __u64,
+pub min_offset: __u64,
+pub max_offset: __u64,
+pub min_transid: __u64,
+pub max_transid: __u64,
+pub min_type: __u32,
+pub max_type: __u32,
+pub nr_items: __u32,
+pub unused: __u32,
+pub unused1: __u64,
+pub unused2: __u64,
+pub unused3: __u64,
+pub unused4: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_header {
+pub transid: __u64,
+pub objectid: __u64,
+pub offset: __u64,
+pub type_: __u32,
+pub len: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_search_args {
+pub key: btrfs_ioctl_search_key,
+pub buf: [crate::ctypes::c_char; 3992usize],
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_search_args_v2 {
+pub key: btrfs_ioctl_search_key,
+pub buf_size: __u64,
+pub buf: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_clone_range_args {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct btrfs_ioctl_defrag_range_args {
+pub start: __u64,
+pub len: __u64,
+pub flags: __u64,
+pub extent_thresh: __u32,
+pub __bindgen_anon_1: btrfs_ioctl_defrag_range_args__bindgen_ty_1,
+pub unused: [__u32; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_defrag_range_args__bindgen_ty_1__bindgen_ty_1 {
+pub type_: __u8,
+pub level: __s8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_same_extent_info {
+pub fd: __s64,
+pub logical_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_same_args {
+pub logical_offset: __u64,
+pub length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<btrfs_ioctl_same_extent_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_space_info {
+pub flags: __u64,
+pub total_bytes: __u64,
+pub used_bytes: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_ioctl_space_args {
+pub space_slots: __u64,
+pub total_spaces: __u64,
+pub spaces: __IncompleteArrayField<btrfs_ioctl_space_info>,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_data_container {
+pub bytes_left: __u32,
+pub bytes_missing: __u32,
+pub elem_cnt: __u32,
+pub elem_missed: __u32,
+pub val: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_ino_path_args {
+pub inum: __u64,
+pub size: __u64,
+pub reserved: [__u64; 4usize],
+pub fspath: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_logical_ino_args {
+pub logical: __u64,
+pub size: __u64,
+pub reserved: [__u64; 3usize],
+pub flags: __u64,
+pub inodes: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_dev_stats {
+pub devid: __u64,
+pub nr_items: __u64,
+pub flags: __u64,
+pub values: [__u64; 5usize],
+pub unused: [__u64; 121usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_quota_ctl_args {
+pub cmd: __u64,
+pub status: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_quota_rescan_args {
+pub flags: __u64,
+pub progress: __u64,
+pub reserved: [__u64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_assign_args {
+pub assign: __u64,
+pub src: __u64,
+pub dst: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_qgroup_create_args {
+pub create: __u64,
+pub qgroupid: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_timespec {
+pub sec: __u64,
+pub nsec: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_received_subvol_args {
+pub uuid: [crate::ctypes::c_char; 16usize],
+pub stransid: __u64,
+pub rtransid: __u64,
+pub stime: btrfs_ioctl_timespec,
+pub rtime: btrfs_ioctl_timespec,
+pub flags: __u64,
+pub reserved: [__u64; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_send_args {
+pub send_fd: __s64,
+pub clone_sources_count: __u64,
+pub clone_sources: *mut __u64,
+pub parent_root: __u64,
+pub flags: __u64,
+pub version: __u32,
+pub reserved: [__u8; 28usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_info_args {
+pub treeid: __u64,
+pub name: [crate::ctypes::c_char; 256usize],
+pub parent_id: __u64,
+pub dirid: __u64,
+pub generation: __u64,
+pub flags: __u64,
+pub uuid: [__u8; 16usize],
+pub parent_uuid: [__u8; 16usize],
+pub received_uuid: [__u8; 16usize],
+pub ctransid: __u64,
+pub otransid: __u64,
+pub stransid: __u64,
+pub rtransid: __u64,
+pub ctime: btrfs_ioctl_timespec,
+pub otime: btrfs_ioctl_timespec,
+pub stime: btrfs_ioctl_timespec,
+pub rtime: btrfs_ioctl_timespec,
+pub reserved: [__u64; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_rootref_args {
+pub min_treeid: __u64,
+pub rootref: [btrfs_ioctl_get_subvol_rootref_args__bindgen_ty_1; 255usize],
+pub num_items: __u8,
+pub align: [__u8; 7usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_get_subvol_rootref_args__bindgen_ty_1 {
+pub treeid: __u64,
+pub dirid: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_encoded_io_args {
+pub iov: *const iovec,
+pub iovcnt: crate::ctypes::c_ulong,
+pub offset: __s64,
+pub flags: __u64,
+pub len: __u64,
+pub unencoded_len: __u64,
+pub unencoded_offset: __u64,
+pub compression: __u32,
+pub encryption: __u32,
+pub reserved: [__u8; 64usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_ioctl_subvol_wait {
+pub subvolid: __u64,
+pub mode: __u32,
+pub count: __u32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_key {
+pub objectid: __le64,
+pub type_: __u8,
+pub offset: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_key {
+pub objectid: __u64,
+pub type_: __u8,
+pub offset: __u64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_header {
+pub csum: [__u8; 32usize],
+pub fsid: [__u8; 16usize],
+pub bytenr: __le64,
+pub flags: __le64,
+pub chunk_tree_uuid: [__u8; 16usize],
+pub generation: __le64,
+pub owner: __le64,
+pub nritems: __le32,
+pub level: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_backup {
+pub tree_root: __le64,
+pub tree_root_gen: __le64,
+pub chunk_root: __le64,
+pub chunk_root_gen: __le64,
+pub extent_root: __le64,
+pub extent_root_gen: __le64,
+pub fs_root: __le64,
+pub fs_root_gen: __le64,
+pub dev_root: __le64,
+pub dev_root_gen: __le64,
+pub csum_root: __le64,
+pub csum_root_gen: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub num_devices: __le64,
+pub unused_64: [__le64; 4usize],
+pub tree_root_level: __u8,
+pub chunk_root_level: __u8,
+pub extent_root_level: __u8,
+pub fs_root_level: __u8,
+pub dev_root_level: __u8,
+pub csum_root_level: __u8,
+pub unused_8: [__u8; 10usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_item {
+pub key: btrfs_disk_key,
+pub offset: __le32,
+pub size: __le32,
+}
+#[repr(C, packed)]
+pub struct btrfs_leaf {
+pub header: btrfs_header,
+pub items: __IncompleteArrayField<btrfs_item>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_key_ptr {
+pub key: btrfs_disk_key,
+pub blockptr: __le64,
+pub generation: __le64,
+}
+#[repr(C, packed)]
+pub struct btrfs_node {
+pub header: btrfs_header,
+pub ptrs: __IncompleteArrayField<btrfs_key_ptr>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_item {
+pub devid: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub io_align: __le32,
+pub io_width: __le32,
+pub sector_size: __le32,
+pub type_: __le64,
+pub generation: __le64,
+pub start_offset: __le64,
+pub dev_group: __le32,
+pub seek_speed: __u8,
+pub bandwidth: __u8,
+pub uuid: [__u8; 16usize],
+pub fsid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_stripe {
+pub devid: __le64,
+pub offset: __le64,
+pub dev_uuid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_chunk {
+pub length: __le64,
+pub owner: __le64,
+pub stripe_len: __le64,
+pub type_: __le64,
+pub io_align: __le32,
+pub io_width: __le32,
+pub sector_size: __le32,
+pub num_stripes: __le16,
+pub sub_stripes: __le16,
+pub stripe: btrfs_stripe,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_super_block {
+pub csum: [__u8; 32usize],
+pub fsid: [__u8; 16usize],
+pub bytenr: __le64,
+pub flags: __le64,
+pub magic: __le64,
+pub generation: __le64,
+pub root: __le64,
+pub chunk_root: __le64,
+pub log_root: __le64,
+pub __unused_log_root_transid: __le64,
+pub total_bytes: __le64,
+pub bytes_used: __le64,
+pub root_dir_objectid: __le64,
+pub num_devices: __le64,
+pub sectorsize: __le32,
+pub nodesize: __le32,
+pub __unused_leafsize: __le32,
+pub stripesize: __le32,
+pub sys_chunk_array_size: __le32,
+pub chunk_root_generation: __le64,
+pub compat_flags: __le64,
+pub compat_ro_flags: __le64,
+pub incompat_flags: __le64,
+pub csum_type: __le16,
+pub root_level: __u8,
+pub chunk_root_level: __u8,
+pub log_root_level: __u8,
+pub dev_item: btrfs_dev_item,
+pub label: [crate::ctypes::c_char; 256usize],
+pub cache_generation: __le64,
+pub uuid_tree_generation: __le64,
+pub metadata_uuid: [__u8; 16usize],
+pub nr_global_roots: __u64,
+pub reserved: [__le64; 27usize],
+pub sys_chunk_array: [__u8; 2048usize],
+pub super_roots: [btrfs_root_backup; 4usize],
+pub padding: [__u8; 565usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_entry {
+pub offset: __le64,
+pub bytes: __le64,
+pub type_: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_header {
+pub location: btrfs_disk_key,
+pub generation: __le64,
+pub num_entries: __le64,
+pub num_bitmaps: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_raid_stride {
+pub devid: __le64,
+pub physical: __le64,
+}
+#[repr(C, packed)]
+pub struct btrfs_stripe_extent {
+pub __bindgen_anon_1: btrfs_stripe_extent__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct btrfs_stripe_extent__bindgen_ty_1 {
+pub __empty_strides: btrfs_stripe_extent__bindgen_ty_1__bindgen_ty_1,
+pub strides: __IncompleteArrayField<btrfs_raid_stride>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_stripe_extent__bindgen_ty_1__bindgen_ty_1 {}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_item {
+pub refs: __le64,
+pub generation: __le64,
+pub flags: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_item_v0 {
+pub refs: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_tree_block_info {
+pub key: btrfs_disk_key,
+pub level: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_data_ref {
+pub root: __le64,
+pub objectid: __le64,
+pub offset: __le64,
+pub count: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_shared_data_ref {
+pub count: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_owner_ref {
+pub root_id: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_extent_inline_ref {
+pub type_: __u8,
+pub offset: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_extent {
+pub chunk_tree: __le64,
+pub chunk_objectid: __le64,
+pub chunk_offset: __le64,
+pub length: __le64,
+pub chunk_tree_uuid: [__u8; 16usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_inode_ref {
+pub index: __le64,
+pub name_len: __le16,
+}
+#[repr(C, packed)]
+pub struct btrfs_inode_extref {
+pub parent_objectid: __le64,
+pub index: __le64,
+pub name_len: __le16,
+pub name: __IncompleteArrayField<__u8>,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_timespec {
+pub sec: __le64,
+pub nsec: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_inode_item {
+pub generation: __le64,
+pub transid: __le64,
+pub size: __le64,
+pub nbytes: __le64,
+pub block_group: __le64,
+pub nlink: __le32,
+pub uid: __le32,
+pub gid: __le32,
+pub mode: __le32,
+pub rdev: __le64,
+pub flags: __le64,
+pub sequence: __le64,
+pub reserved: [__le64; 4usize],
+pub atime: btrfs_timespec,
+pub ctime: btrfs_timespec,
+pub mtime: btrfs_timespec,
+pub otime: btrfs_timespec,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dir_log_item {
+pub end: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dir_item {
+pub location: btrfs_disk_key,
+pub transid: __le64,
+pub data_len: __le16,
+pub name_len: __le16,
+pub type_: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_item {
+pub inode: btrfs_inode_item,
+pub generation: __le64,
+pub root_dirid: __le64,
+pub bytenr: __le64,
+pub byte_limit: __le64,
+pub bytes_used: __le64,
+pub last_snapshot: __le64,
+pub flags: __le64,
+pub refs: __le32,
+pub drop_progress: btrfs_disk_key,
+pub drop_level: __u8,
+pub level: __u8,
+pub generation_v2: __le64,
+pub uuid: [__u8; 16usize],
+pub parent_uuid: [__u8; 16usize],
+pub received_uuid: [__u8; 16usize],
+pub ctransid: __le64,
+pub otransid: __le64,
+pub stransid: __le64,
+pub rtransid: __le64,
+pub ctime: btrfs_timespec,
+pub otime: btrfs_timespec,
+pub stime: btrfs_timespec,
+pub rtime: btrfs_timespec,
+pub reserved: [__le64; 8usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_root_ref {
+pub dirid: __le64,
+pub sequence: __le64,
+pub name_len: __le16,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_disk_balance_args {
+pub profiles: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1,
+pub devid: __le64,
+pub pstart: __le64,
+pub pend: __le64,
+pub vstart: __le64,
+pub vend: __le64,
+pub target: __le64,
+pub flags: __le64,
+pub __bindgen_anon_2: btrfs_disk_balance_args__bindgen_ty_2,
+pub stripes_min: __le32,
+pub stripes_max: __le32,
+pub unused: [__le64; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1 {
+pub usage_min: __le32,
+pub usage_max: __le32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1 {
+pub limit_min: __le32,
+pub limit_max: __le32,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub struct btrfs_balance_item {
+pub flags: __le64,
+pub data: btrfs_disk_balance_args,
+pub meta: btrfs_disk_balance_args,
+pub sys: btrfs_disk_balance_args,
+pub unused: [__le64; 4usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_file_extent_item {
+pub generation: __le64,
+pub ram_bytes: __le64,
+pub compression: __u8,
+pub encryption: __u8,
+pub other_encoding: __le16,
+pub type_: __u8,
+pub disk_bytenr: __le64,
+pub disk_num_bytes: __le64,
+pub offset: __le64,
+pub num_bytes: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_csum_item {
+pub csum: __u8,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_stats_item {
+pub values: [__le64; 5usize],
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_dev_replace_item {
+pub src_devid: __le64,
+pub cursor_left: __le64,
+pub cursor_right: __le64,
+pub cont_reading_from_srcdev_mode: __le64,
+pub replace_state: __le64,
+pub time_started: __le64,
+pub time_stopped: __le64,
+pub num_write_errors: __le64,
+pub num_uncorrectable_read_errors: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_block_group_item {
+pub used: __le64,
+pub chunk_objectid: __le64,
+pub flags: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_free_space_info {
+pub extent_count: __le32,
+pub flags: __le32,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_status_item {
+pub version: __le64,
+pub generation: __le64,
+pub flags: __le64,
+pub rescan: __le64,
+pub enable_gen: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_info_item {
+pub generation: __le64,
+pub rfer: __le64,
+pub rfer_cmpr: __le64,
+pub excl: __le64,
+pub excl_cmpr: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_qgroup_limit_item {
+pub flags: __le64,
+pub max_rfer: __le64,
+pub max_excl: __le64,
+pub rsv_rfer: __le64,
+pub rsv_excl: __le64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct btrfs_verity_descriptor_item {
+pub size: __le64,
+pub reserved: [__le64; 2usize],
+pub encryption: __u8,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct iovec {
+pub _address: u8,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const _IOC_NRBITS: u32 = 8;
+pub const _IOC_TYPEBITS: u32 = 8;
+pub const _IOC_SIZEBITS: u32 = 14;
+pub const _IOC_DIRBITS: u32 = 2;
+pub const _IOC_NRMASK: u32 = 255;
+pub const _IOC_TYPEMASK: u32 = 255;
+pub const _IOC_SIZEMASK: u32 = 16383;
+pub const _IOC_DIRMASK: u32 = 3;
+pub const _IOC_NRSHIFT: u32 = 0;
+pub const _IOC_TYPESHIFT: u32 = 8;
+pub const _IOC_SIZESHIFT: u32 = 16;
+pub const _IOC_DIRSHIFT: u32 = 30;
+pub const _IOC_NONE: u32 = 0;
+pub const _IOC_WRITE: u32 = 1;
+pub const _IOC_READ: u32 = 2;
+pub const IOC_IN: u32 = 1073741824;
+pub const IOC_OUT: u32 = 2147483648;
+pub const IOC_INOUT: u32 = 3221225472;
+pub const IOCSIZE_MASK: u32 = 1073676288;
+pub const IOCSIZE_SHIFT: u32 = 16;
+pub const NR_OPEN: u32 = 1024;
+pub const NGROUPS_MAX: u32 = 65536;
+pub const ARG_MAX: u32 = 131072;
+pub const LINK_MAX: u32 = 127;
+pub const MAX_CANON: u32 = 255;
+pub const MAX_INPUT: u32 = 255;
+pub const NAME_MAX: u32 = 255;
+pub const PATH_MAX: u32 = 4096;
+pub const PIPE_BUF: u32 = 4096;
+pub const XATTR_NAME_MAX: u32 = 255;
+pub const XATTR_SIZE_MAX: u32 = 65536;
+pub const XATTR_LIST_MAX: u32 = 65536;
+pub const RTSIG_MAX: u32 = 32;
+pub const FSCRYPT_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FSCRYPT_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FSCRYPT_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FSCRYPT_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FSCRYPT_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FSCRYPT_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64: u32 = 8;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32: u32 = 16;
+pub const FSCRYPT_MODE_AES_256_XTS: u32 = 1;
+pub const FSCRYPT_MODE_AES_256_CTS: u32 = 4;
+pub const FSCRYPT_MODE_AES_128_CBC: u32 = 5;
+pub const FSCRYPT_MODE_AES_128_CTS: u32 = 6;
+pub const FSCRYPT_MODE_SM4_XTS: u32 = 7;
+pub const FSCRYPT_MODE_SM4_CTS: u32 = 8;
+pub const FSCRYPT_MODE_ADIANTUM: u32 = 9;
+pub const FSCRYPT_MODE_AES_256_HCTR2: u32 = 10;
+pub const FSCRYPT_POLICY_V1: u32 = 0;
+pub const FSCRYPT_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FSCRYPT_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FSCRYPT_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FSCRYPT_MAX_KEY_SIZE: u32 = 64;
+pub const FSCRYPT_POLICY_V2: u32 = 2;
+pub const FSCRYPT_KEY_IDENTIFIER_SIZE: u32 = 16;
+pub const FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: u32 = 1;
+pub const FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: u32 = 2;
+pub const FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSY: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERS: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_ABSENT: u32 = 1;
+pub const FSCRYPT_KEY_STATUS_PRESENT: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVED: u32 = 3;
+pub const FSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELF: u32 = 1;
+pub const FS_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FS_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FS_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FS_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FS_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FS_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FS_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FS_POLICY_FLAGS_VALID: u32 = 7;
+pub const FS_ENCRYPTION_MODE_INVALID: u32 = 0;
+pub const FS_ENCRYPTION_MODE_AES_256_XTS: u32 = 1;
+pub const FS_ENCRYPTION_MODE_AES_256_GCM: u32 = 2;
+pub const FS_ENCRYPTION_MODE_AES_256_CBC: u32 = 3;
+pub const FS_ENCRYPTION_MODE_AES_256_CTS: u32 = 4;
+pub const FS_ENCRYPTION_MODE_AES_128_CBC: u32 = 5;
+pub const FS_ENCRYPTION_MODE_AES_128_CTS: u32 = 6;
+pub const FS_ENCRYPTION_MODE_ADIANTUM: u32 = 9;
+pub const FS_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FS_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FS_MAX_KEY_SIZE: u32 = 64;
+pub const MS_RDONLY: u32 = 1;
+pub const MS_NOSUID: u32 = 2;
+pub const MS_NODEV: u32 = 4;
+pub const MS_NOEXEC: u32 = 8;
+pub const MS_SYNCHRONOUS: u32 = 16;
+pub const MS_REMOUNT: u32 = 32;
+pub const MS_MANDLOCK: u32 = 64;
+pub const MS_DIRSYNC: u32 = 128;
+pub const MS_NOSYMFOLLOW: u32 = 256;
+pub const MS_NOATIME: u32 = 1024;
+pub const MS_NODIRATIME: u32 = 2048;
+pub const MS_BIND: u32 = 4096;
+pub const MS_MOVE: u32 = 8192;
+pub const MS_REC: u32 = 16384;
+pub const MS_VERBOSE: u32 = 32768;
+pub const MS_SILENT: u32 = 32768;
+pub const MS_POSIXACL: u32 = 65536;
+pub const MS_UNBINDABLE: u32 = 131072;
+pub const MS_PRIVATE: u32 = 262144;
+pub const MS_SLAVE: u32 = 524288;
+pub const MS_SHARED: u32 = 1048576;
+pub const MS_RELATIME: u32 = 2097152;
+pub const MS_KERNMOUNT: u32 = 4194304;
+pub const MS_I_VERSION: u32 = 8388608;
+pub const MS_STRICTATIME: u32 = 16777216;
+pub const MS_LAZYTIME: u32 = 33554432;
+pub const MS_SUBMOUNT: u32 = 67108864;
+pub const MS_NOREMOTELOCK: u32 = 134217728;
+pub const MS_NOSEC: u32 = 268435456;
+pub const MS_BORN: u32 = 536870912;
+pub const MS_ACTIVE: u32 = 1073741824;
+pub const MS_NOUSER: u32 = 2147483648;
+pub const MS_RMT_MASK: u32 = 41943121;
+pub const MS_MGC_VAL: u32 = 3236757504;
+pub const MS_MGC_MSK: u32 = 4294901760;
+pub const OPEN_TREE_CLONE: u32 = 1;
+pub const MOVE_MOUNT_F_SYMLINKS: u32 = 1;
+pub const MOVE_MOUNT_F_AUTOMOUNTS: u32 = 2;
+pub const MOVE_MOUNT_F_EMPTY_PATH: u32 = 4;
+pub const MOVE_MOUNT_T_SYMLINKS: u32 = 16;
+pub const MOVE_MOUNT_T_AUTOMOUNTS: u32 = 32;
+pub const MOVE_MOUNT_T_EMPTY_PATH: u32 = 64;
+pub const MOVE_MOUNT_SET_GROUP: u32 = 256;
+pub const MOVE_MOUNT_BENEATH: u32 = 512;
+pub const MOVE_MOUNT__MASK: u32 = 887;
+pub const FSOPEN_CLOEXEC: u32 = 1;
+pub const FSPICK_CLOEXEC: u32 = 1;
+pub const FSPICK_SYMLINK_NOFOLLOW: u32 = 2;
+pub const FSPICK_NO_AUTOMOUNT: u32 = 4;
+pub const FSPICK_EMPTY_PATH: u32 = 8;
+pub const FSMOUNT_CLOEXEC: u32 = 1;
+pub const MOUNT_ATTR_RDONLY: u32 = 1;
+pub const MOUNT_ATTR_NOSUID: u32 = 2;
+pub const MOUNT_ATTR_NODEV: u32 = 4;
+pub const MOUNT_ATTR_NOEXEC: u32 = 8;
+pub const MOUNT_ATTR__ATIME: u32 = 112;
+pub const MOUNT_ATTR_RELATIME: u32 = 0;
+pub const MOUNT_ATTR_NOATIME: u32 = 16;
+pub const MOUNT_ATTR_STRICTATIME: u32 = 32;
+pub const MOUNT_ATTR_NODIRATIME: u32 = 128;
+pub const MOUNT_ATTR_IDMAP: u32 = 1048576;
+pub const MOUNT_ATTR_NOSYMFOLLOW: u32 = 2097152;
+pub const MOUNT_ATTR_SIZE_VER0: u32 = 32;
+pub const MNT_ID_REQ_SIZE_VER0: u32 = 24;
+pub const MNT_ID_REQ_SIZE_VER1: u32 = 32;
+pub const STATMOUNT_SB_BASIC: u32 = 1;
+pub const STATMOUNT_MNT_BASIC: u32 = 2;
+pub const STATMOUNT_PROPAGATE_FROM: u32 = 4;
+pub const STATMOUNT_MNT_ROOT: u32 = 8;
+pub const STATMOUNT_MNT_POINT: u32 = 16;
+pub const STATMOUNT_FS_TYPE: u32 = 32;
+pub const STATMOUNT_MNT_NS_ID: u32 = 64;
+pub const STATMOUNT_MNT_OPTS: u32 = 128;
+pub const STATMOUNT_FS_SUBTYPE: u32 = 256;
+pub const STATMOUNT_SB_SOURCE: u32 = 512;
+pub const STATMOUNT_OPT_ARRAY: u32 = 1024;
+pub const STATMOUNT_OPT_SEC_ARRAY: u32 = 2048;
+pub const STATMOUNT_SUPPORTED_MASK: u32 = 4096;
+pub const STATMOUNT_MNT_UIDMAP: u32 = 8192;
+pub const STATMOUNT_MNT_GIDMAP: u32 = 16384;
+pub const LSMT_ROOT: i32 = -1;
+pub const LISTMOUNT_REVERSE: u32 = 1;
+pub const INR_OPEN_CUR: u32 = 1024;
+pub const INR_OPEN_MAX: u32 = 4096;
+pub const BLOCK_SIZE_BITS: u32 = 10;
+pub const BLOCK_SIZE: u32 = 1024;
+pub const IO_INTEGRITY_CHK_GUARD: u32 = 1;
+pub const IO_INTEGRITY_CHK_REFTAG: u32 = 2;
+pub const IO_INTEGRITY_CHK_APPTAG: u32 = 4;
+pub const IO_INTEGRITY_VALID_FLAGS: u32 = 7;
+pub const SEEK_SET: u32 = 0;
+pub const SEEK_CUR: u32 = 1;
+pub const SEEK_END: u32 = 2;
+pub const SEEK_DATA: u32 = 3;
+pub const SEEK_HOLE: u32 = 4;
+pub const SEEK_MAX: u32 = 4;
+pub const RENAME_NOREPLACE: u32 = 1;
+pub const RENAME_EXCHANGE: u32 = 2;
+pub const RENAME_WHITEOUT: u32 = 4;
+pub const FILE_DEDUPE_RANGE_SAME: u32 = 0;
+pub const FILE_DEDUPE_RANGE_DIFFERS: u32 = 1;
+pub const NR_FILE: u32 = 8192;
+pub const FS_XFLAG_REALTIME: u32 = 1;
+pub const FS_XFLAG_PREALLOC: u32 = 2;
+pub const FS_XFLAG_IMMUTABLE: u32 = 8;
+pub const FS_XFLAG_APPEND: u32 = 16;
+pub const FS_XFLAG_SYNC: u32 = 32;
+pub const FS_XFLAG_NOATIME: u32 = 64;
+pub const FS_XFLAG_NODUMP: u32 = 128;
+pub const FS_XFLAG_RTINHERIT: u32 = 256;
+pub const FS_XFLAG_PROJINHERIT: u32 = 512;
+pub const FS_XFLAG_NOSYMLINKS: u32 = 1024;
+pub const FS_XFLAG_EXTSIZE: u32 = 2048;
+pub const FS_XFLAG_EXTSZINHERIT: u32 = 4096;
+pub const FS_XFLAG_NODEFRAG: u32 = 8192;
+pub const FS_XFLAG_FILESTREAM: u32 = 16384;
+pub const FS_XFLAG_DAX: u32 = 32768;
+pub const FS_XFLAG_COWEXTSIZE: u32 = 65536;
+pub const FS_XFLAG_HASATTR: u32 = 2147483648;
+pub const BMAP_IOCTL: u32 = 1;
+pub const FSLABEL_MAX: u32 = 256;
+pub const FS_SECRM_FL: u32 = 1;
+pub const FS_UNRM_FL: u32 = 2;
+pub const FS_COMPR_FL: u32 = 4;
+pub const FS_SYNC_FL: u32 = 8;
+pub const FS_IMMUTABLE_FL: u32 = 16;
+pub const FS_APPEND_FL: u32 = 32;
+pub const FS_NODUMP_FL: u32 = 64;
+pub const FS_NOATIME_FL: u32 = 128;
+pub const FS_DIRTY_FL: u32 = 256;
+pub const FS_COMPRBLK_FL: u32 = 512;
+pub const FS_NOCOMP_FL: u32 = 1024;
+pub const FS_ENCRYPT_FL: u32 = 2048;
+pub const FS_BTREE_FL: u32 = 4096;
+pub const FS_INDEX_FL: u32 = 4096;
+pub const FS_IMAGIC_FL: u32 = 8192;
+pub const FS_JOURNAL_DATA_FL: u32 = 16384;
+pub const FS_NOTAIL_FL: u32 = 32768;
+pub const FS_DIRSYNC_FL: u32 = 65536;
+pub const FS_TOPDIR_FL: u32 = 131072;
+pub const FS_HUGE_FILE_FL: u32 = 262144;
+pub const FS_EXTENT_FL: u32 = 524288;
+pub const FS_VERITY_FL: u32 = 1048576;
+pub const FS_EA_INODE_FL: u32 = 2097152;
+pub const FS_EOFBLOCKS_FL: u32 = 4194304;
+pub const FS_NOCOW_FL: u32 = 8388608;
+pub const FS_DAX_FL: u32 = 33554432;
+pub const FS_INLINE_DATA_FL: u32 = 268435456;
+pub const FS_PROJINHERIT_FL: u32 = 536870912;
+pub const FS_CASEFOLD_FL: u32 = 1073741824;
+pub const FS_RESERVED_FL: u32 = 2147483648;
+pub const FS_FL_USER_VISIBLE: u32 = 253951;
+pub const FS_FL_USER_MODIFIABLE: u32 = 229631;
+pub const SYNC_FILE_RANGE_WAIT_BEFORE: u32 = 1;
+pub const SYNC_FILE_RANGE_WRITE: u32 = 2;
+pub const SYNC_FILE_RANGE_WAIT_AFTER: u32 = 4;
+pub const SYNC_FILE_RANGE_WRITE_AND_WAIT: u32 = 7;
+pub const PROCFS_IOCTL_MAGIC: u8 = 102u8;
+pub const PAGE_IS_WPALLOWED: u32 = 1;
+pub const PAGE_IS_WRITTEN: u32 = 2;
+pub const PAGE_IS_FILE: u32 = 4;
+pub const PAGE_IS_PRESENT: u32 = 8;
+pub const PAGE_IS_SWAPPED: u32 = 16;
+pub const PAGE_IS_PFNZERO: u32 = 32;
+pub const PAGE_IS_HUGE: u32 = 64;
+pub const PAGE_IS_SOFT_DIRTY: u32 = 128;
+pub const PAGE_IS_GUARD: u32 = 256;
+pub const PM_SCAN_WP_MATCHING: u32 = 1;
+pub const PM_SCAN_CHECK_WPASYNC: u32 = 2;
+pub const BTRFS_IOCTL_MAGIC: u32 = 148;
+pub const BTRFS_VOL_NAME_MAX: u32 = 255;
+pub const BTRFS_LABEL_SIZE: u32 = 256;
+pub const BTRFS_PATH_NAME_MAX: u32 = 4087;
+pub const BTRFS_DEVICE_PATH_NAME_MAX: u32 = 1024;
+pub const BTRFS_SUBVOL_NAME_MAX: u32 = 4039;
+pub const BTRFS_SUBVOL_CREATE_ASYNC: u32 = 1;
+pub const BTRFS_SUBVOL_RDONLY: u32 = 2;
+pub const BTRFS_SUBVOL_QGROUP_INHERIT: u32 = 4;
+pub const BTRFS_DEVICE_SPEC_BY_ID: u32 = 8;
+pub const BTRFS_SUBVOL_SPEC_BY_ID: u32 = 16;
+pub const BTRFS_VOL_ARG_V2_FLAGS_SUPPORTED: u32 = 30;
+pub const BTRFS_FSID_SIZE: u32 = 16;
+pub const BTRFS_UUID_SIZE: u32 = 16;
+pub const BTRFS_UUID_UNPARSED_SIZE: u32 = 37;
+pub const BTRFS_QGROUP_LIMIT_MAX_RFER: u32 = 1;
+pub const BTRFS_QGROUP_LIMIT_MAX_EXCL: u32 = 2;
+pub const BTRFS_QGROUP_LIMIT_RSV_RFER: u32 = 4;
+pub const BTRFS_QGROUP_LIMIT_RSV_EXCL: u32 = 8;
+pub const BTRFS_QGROUP_LIMIT_RFER_CMPR: u32 = 16;
+pub const BTRFS_QGROUP_LIMIT_EXCL_CMPR: u32 = 32;
+pub const BTRFS_QGROUP_INHERIT_SET_LIMITS: u32 = 1;
+pub const BTRFS_QGROUP_INHERIT_FLAGS_SUPP: u32 = 1;
+pub const BTRFS_DEVICE_REMOVE_ARGS_MASK: u32 = 8;
+pub const BTRFS_SUBVOL_CREATE_ARGS_MASK: u32 = 6;
+pub const BTRFS_SUBVOL_DELETE_ARGS_MASK: u32 = 16;
+pub const BTRFS_SCRUB_READONLY: u32 = 1;
+pub const BTRFS_SCRUB_SUPPORTED_FLAGS: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_NEVER_STARTED: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_STARTED: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_FINISHED: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_CANCELED: u32 = 3;
+pub const BTRFS_IOCTL_DEV_REPLACE_STATE_SUSPENDED: u32 = 4;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_START: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_STATUS: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_CMD_CANCEL: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NO_ERROR: u32 = 0;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_NOT_STARTED: u32 = 1;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_ALREADY_STARTED: u32 = 2;
+pub const BTRFS_IOCTL_DEV_REPLACE_RESULT_SCRUB_INPROGRESS: u32 = 3;
+pub const BTRFS_FS_INFO_FLAG_CSUM_INFO: u32 = 1;
+pub const BTRFS_FS_INFO_FLAG_GENERATION: u32 = 2;
+pub const BTRFS_FS_INFO_FLAG_METADATA_UUID: u32 = 4;
+pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE: u32 = 1;
+pub const BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID: u32 = 2;
+pub const BTRFS_FEATURE_COMPAT_RO_VERITY: u32 = 4;
+pub const BTRFS_FEATURE_COMPAT_RO_BLOCK_GROUP_TREE: u32 = 8;
+pub const BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF: u32 = 1;
+pub const BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL: u32 = 2;
+pub const BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS: u32 = 4;
+pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO: u32 = 8;
+pub const BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD: u32 = 16;
+pub const BTRFS_FEATURE_INCOMPAT_BIG_METADATA: u32 = 32;
+pub const BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF: u32 = 64;
+pub const BTRFS_FEATURE_INCOMPAT_RAID56: u32 = 128;
+pub const BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA: u32 = 256;
+pub const BTRFS_FEATURE_INCOMPAT_NO_HOLES: u32 = 512;
+pub const BTRFS_FEATURE_INCOMPAT_METADATA_UUID: u32 = 1024;
+pub const BTRFS_FEATURE_INCOMPAT_RAID1C34: u32 = 2048;
+pub const BTRFS_FEATURE_INCOMPAT_ZONED: u32 = 4096;
+pub const BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2: u32 = 8192;
+pub const BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE: u32 = 16384;
+pub const BTRFS_FEATURE_INCOMPAT_SIMPLE_QUOTA: u32 = 65536;
+pub const BTRFS_BALANCE_CTL_PAUSE: u32 = 1;
+pub const BTRFS_BALANCE_CTL_CANCEL: u32 = 2;
+pub const BTRFS_BALANCE_DATA: u32 = 1;
+pub const BTRFS_BALANCE_SYSTEM: u32 = 2;
+pub const BTRFS_BALANCE_METADATA: u32 = 4;
+pub const BTRFS_BALANCE_TYPE_MASK: u32 = 7;
+pub const BTRFS_BALANCE_FORCE: u32 = 8;
+pub const BTRFS_BALANCE_RESUME: u32 = 16;
+pub const BTRFS_BALANCE_ARGS_PROFILES: u32 = 1;
+pub const BTRFS_BALANCE_ARGS_USAGE: u32 = 2;
+pub const BTRFS_BALANCE_ARGS_DEVID: u32 = 4;
+pub const BTRFS_BALANCE_ARGS_DRANGE: u32 = 8;
+pub const BTRFS_BALANCE_ARGS_VRANGE: u32 = 16;
+pub const BTRFS_BALANCE_ARGS_LIMIT: u32 = 32;
+pub const BTRFS_BALANCE_ARGS_LIMIT_RANGE: u32 = 64;
+pub const BTRFS_BALANCE_ARGS_STRIPES_RANGE: u32 = 128;
+pub const BTRFS_BALANCE_ARGS_USAGE_RANGE: u32 = 1024;
+pub const BTRFS_BALANCE_ARGS_MASK: u32 = 1279;
+pub const BTRFS_BALANCE_ARGS_CONVERT: u32 = 256;
+pub const BTRFS_BALANCE_ARGS_SOFT: u32 = 512;
+pub const BTRFS_BALANCE_STATE_RUNNING: u32 = 1;
+pub const BTRFS_BALANCE_STATE_PAUSE_REQ: u32 = 2;
+pub const BTRFS_BALANCE_STATE_CANCEL_REQ: u32 = 4;
+pub const BTRFS_INO_LOOKUP_PATH_MAX: u32 = 4080;
+pub const BTRFS_INO_LOOKUP_USER_PATH_MAX: u32 = 3824;
+pub const BTRFS_DEFRAG_RANGE_COMPRESS: u32 = 1;
+pub const BTRFS_DEFRAG_RANGE_START_IO: u32 = 2;
+pub const BTRFS_DEFRAG_RANGE_COMPRESS_LEVEL: u32 = 4;
+pub const BTRFS_DEFRAG_RANGE_FLAGS_SUPP: u32 = 7;
+pub const BTRFS_SAME_DATA_DIFFERS: u32 = 1;
+pub const BTRFS_LOGICAL_INO_ARGS_IGNORE_OFFSET: u32 = 1;
+pub const BTRFS_DEV_STATS_RESET: u32 = 1;
+pub const BTRFS_QUOTA_CTL_ENABLE: u32 = 1;
+pub const BTRFS_QUOTA_CTL_DISABLE: u32 = 2;
+pub const BTRFS_QUOTA_CTL_RESCAN__NOTUSED: u32 = 3;
+pub const BTRFS_QUOTA_CTL_ENABLE_SIMPLE_QUOTA: u32 = 4;
+pub const BTRFS_SEND_FLAG_NO_FILE_DATA: u32 = 1;
+pub const BTRFS_SEND_FLAG_OMIT_STREAM_HEADER: u32 = 2;
+pub const BTRFS_SEND_FLAG_OMIT_END_CMD: u32 = 4;
+pub const BTRFS_SEND_FLAG_VERSION: u32 = 8;
+pub const BTRFS_SEND_FLAG_COMPRESSED: u32 = 16;
+pub const BTRFS_SEND_FLAG_MASK: u32 = 31;
+pub const BTRFS_MAX_ROOTREF_BUFFER_NUM: u32 = 255;
+pub const BTRFS_ENCODED_IO_COMPRESSION_NONE: u32 = 0;
+pub const BTRFS_ENCODED_IO_COMPRESSION_ZLIB: u32 = 1;
+pub const BTRFS_ENCODED_IO_COMPRESSION_ZSTD: u32 = 2;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_4K: u32 = 3;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_8K: u32 = 4;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_16K: u32 = 5;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_32K: u32 = 6;
+pub const BTRFS_ENCODED_IO_COMPRESSION_LZO_64K: u32 = 7;
+pub const BTRFS_ENCODED_IO_COMPRESSION_TYPES: u32 = 8;
+pub const BTRFS_ENCODED_IO_ENCRYPTION_NONE: u32 = 0;
+pub const BTRFS_ENCODED_IO_ENCRYPTION_TYPES: u32 = 1;
+pub const BTRFS_SUBVOL_SYNC_WAIT_FOR_ONE: u32 = 0;
+pub const BTRFS_SUBVOL_SYNC_WAIT_FOR_QUEUED: u32 = 1;
+pub const BTRFS_SUBVOL_SYNC_COUNT: u32 = 2;
+pub const BTRFS_SUBVOL_SYNC_PEEK_FIRST: u32 = 3;
+pub const BTRFS_SUBVOL_SYNC_PEEK_LAST: u32 = 4;
+pub const BTRFS_MAGIC: u64 = 5575266562640200287;
+pub const BTRFS_MAX_LEVEL: u32 = 8;
+pub const BTRFS_NAME_LEN: u32 = 255;
+pub const BTRFS_LINK_MAX: u32 = 65535;
+pub const BTRFS_ROOT_TREE_OBJECTID: u32 = 1;
+pub const BTRFS_EXTENT_TREE_OBJECTID: u32 = 2;
+pub const BTRFS_CHUNK_TREE_OBJECTID: u32 = 3;
+pub const BTRFS_DEV_TREE_OBJECTID: u32 = 4;
+pub const BTRFS_FS_TREE_OBJECTID: u32 = 5;
+pub const BTRFS_ROOT_TREE_DIR_OBJECTID: u32 = 6;
+pub const BTRFS_CSUM_TREE_OBJECTID: u32 = 7;
+pub const BTRFS_QUOTA_TREE_OBJECTID: u32 = 8;
+pub const BTRFS_UUID_TREE_OBJECTID: u32 = 9;
+pub const BTRFS_FREE_SPACE_TREE_OBJECTID: u32 = 10;
+pub const BTRFS_BLOCK_GROUP_TREE_OBJECTID: u32 = 11;
+pub const BTRFS_RAID_STRIPE_TREE_OBJECTID: u32 = 12;
+pub const BTRFS_DEV_STATS_OBJECTID: u32 = 0;
+pub const BTRFS_BALANCE_OBJECTID: i32 = -4;
+pub const BTRFS_ORPHAN_OBJECTID: i32 = -5;
+pub const BTRFS_TREE_LOG_OBJECTID: i32 = -6;
+pub const BTRFS_TREE_LOG_FIXUP_OBJECTID: i32 = -7;
+pub const BTRFS_TREE_RELOC_OBJECTID: i32 = -8;
+pub const BTRFS_DATA_RELOC_TREE_OBJECTID: i32 = -9;
+pub const BTRFS_EXTENT_CSUM_OBJECTID: i32 = -10;
+pub const BTRFS_FREE_SPACE_OBJECTID: i32 = -11;
+pub const BTRFS_FREE_INO_OBJECTID: i32 = -12;
+pub const BTRFS_MULTIPLE_OBJECTIDS: i32 = -255;
+pub const BTRFS_FIRST_FREE_OBJECTID: u32 = 256;
+pub const BTRFS_LAST_FREE_OBJECTID: i32 = -256;
+pub const BTRFS_FIRST_CHUNK_TREE_OBJECTID: u32 = 256;
+pub const BTRFS_DEV_ITEMS_OBJECTID: u32 = 1;
+pub const BTRFS_BTREE_INODE_OBJECTID: u32 = 1;
+pub const BTRFS_EMPTY_SUBVOL_DIR_OBJECTID: u32 = 2;
+pub const BTRFS_DEV_REPLACE_DEVID: u32 = 0;
+pub const BTRFS_INODE_ITEM_KEY: u32 = 1;
+pub const BTRFS_INODE_REF_KEY: u32 = 12;
+pub const BTRFS_INODE_EXTREF_KEY: u32 = 13;
+pub const BTRFS_XATTR_ITEM_KEY: u32 = 24;
+pub const BTRFS_VERITY_DESC_ITEM_KEY: u32 = 36;
+pub const BTRFS_VERITY_MERKLE_ITEM_KEY: u32 = 37;
+pub const BTRFS_ORPHAN_ITEM_KEY: u32 = 48;
+pub const BTRFS_DIR_LOG_ITEM_KEY: u32 = 60;
+pub const BTRFS_DIR_LOG_INDEX_KEY: u32 = 72;
+pub const BTRFS_DIR_ITEM_KEY: u32 = 84;
+pub const BTRFS_DIR_INDEX_KEY: u32 = 96;
+pub const BTRFS_EXTENT_DATA_KEY: u32 = 108;
+pub const BTRFS_EXTENT_CSUM_KEY: u32 = 128;
+pub const BTRFS_ROOT_ITEM_KEY: u32 = 132;
+pub const BTRFS_ROOT_BACKREF_KEY: u32 = 144;
+pub const BTRFS_ROOT_REF_KEY: u32 = 156;
+pub const BTRFS_EXTENT_ITEM_KEY: u32 = 168;
+pub const BTRFS_METADATA_ITEM_KEY: u32 = 169;
+pub const BTRFS_EXTENT_OWNER_REF_KEY: u32 = 172;
+pub const BTRFS_TREE_BLOCK_REF_KEY: u32 = 176;
+pub const BTRFS_EXTENT_DATA_REF_KEY: u32 = 178;
+pub const BTRFS_SHARED_BLOCK_REF_KEY: u32 = 182;
+pub const BTRFS_SHARED_DATA_REF_KEY: u32 = 184;
+pub const BTRFS_BLOCK_GROUP_ITEM_KEY: u32 = 192;
+pub const BTRFS_FREE_SPACE_INFO_KEY: u32 = 198;
+pub const BTRFS_FREE_SPACE_EXTENT_KEY: u32 = 199;
+pub const BTRFS_FREE_SPACE_BITMAP_KEY: u32 = 200;
+pub const BTRFS_DEV_EXTENT_KEY: u32 = 204;
+pub const BTRFS_DEV_ITEM_KEY: u32 = 216;
+pub const BTRFS_CHUNK_ITEM_KEY: u32 = 228;
+pub const BTRFS_RAID_STRIPE_KEY: u32 = 230;
+pub const BTRFS_QGROUP_STATUS_KEY: u32 = 240;
+pub const BTRFS_QGROUP_INFO_KEY: u32 = 242;
+pub const BTRFS_QGROUP_LIMIT_KEY: u32 = 244;
+pub const BTRFS_QGROUP_RELATION_KEY: u32 = 246;
+pub const BTRFS_BALANCE_ITEM_KEY: u32 = 248;
+pub const BTRFS_TEMPORARY_ITEM_KEY: u32 = 248;
+pub const BTRFS_DEV_STATS_KEY: u32 = 249;
+pub const BTRFS_PERSISTENT_ITEM_KEY: u32 = 249;
+pub const BTRFS_DEV_REPLACE_KEY: u32 = 250;
+pub const BTRFS_UUID_KEY_SUBVOL: u32 = 251;
+pub const BTRFS_UUID_KEY_RECEIVED_SUBVOL: u32 = 252;
+pub const BTRFS_STRING_ITEM_KEY: u32 = 253;
+pub const BTRFS_MAX_METADATA_BLOCKSIZE: u32 = 65536;
+pub const BTRFS_CSUM_SIZE: u32 = 32;
+pub const BTRFS_FT_UNKNOWN: u32 = 0;
+pub const BTRFS_FT_REG_FILE: u32 = 1;
+pub const BTRFS_FT_DIR: u32 = 2;
+pub const BTRFS_FT_CHRDEV: u32 = 3;
+pub const BTRFS_FT_BLKDEV: u32 = 4;
+pub const BTRFS_FT_FIFO: u32 = 5;
+pub const BTRFS_FT_SOCK: u32 = 6;
+pub const BTRFS_FT_SYMLINK: u32 = 7;
+pub const BTRFS_FT_XATTR: u32 = 8;
+pub const BTRFS_FT_MAX: u32 = 9;
+pub const BTRFS_FT_ENCRYPTED: u32 = 128;
+pub const BTRFS_INODE_NODATASUM: u32 = 1;
+pub const BTRFS_INODE_NODATACOW: u32 = 2;
+pub const BTRFS_INODE_READONLY: u32 = 4;
+pub const BTRFS_INODE_NOCOMPRESS: u32 = 8;
+pub const BTRFS_INODE_PREALLOC: u32 = 16;
+pub const BTRFS_INODE_SYNC: u32 = 32;
+pub const BTRFS_INODE_IMMUTABLE: u32 = 64;
+pub const BTRFS_INODE_APPEND: u32 = 128;
+pub const BTRFS_INODE_NODUMP: u32 = 256;
+pub const BTRFS_INODE_NOATIME: u32 = 512;
+pub const BTRFS_INODE_DIRSYNC: u32 = 1024;
+pub const BTRFS_INODE_COMPRESS: u32 = 2048;
+pub const BTRFS_INODE_ROOT_ITEM_INIT: u32 = 2147483648;
+pub const BTRFS_INODE_FLAG_MASK: u32 = 2147487743;
+pub const BTRFS_INODE_RO_VERITY: u32 = 1;
+pub const BTRFS_INODE_RO_FLAG_MASK: u32 = 1;
+pub const BTRFS_SYSTEM_CHUNK_ARRAY_SIZE: u32 = 2048;
+pub const BTRFS_NUM_BACKUP_ROOTS: u32 = 4;
+pub const BTRFS_FREE_SPACE_EXTENT: u32 = 1;
+pub const BTRFS_FREE_SPACE_BITMAP: u32 = 2;
+pub const BTRFS_HEADER_FLAG_WRITTEN: u32 = 1;
+pub const BTRFS_HEADER_FLAG_RELOC: u32 = 2;
+pub const BTRFS_SUPER_FLAG_ERROR: u32 = 4;
+pub const BTRFS_SUPER_FLAG_SEEDING: u64 = 4294967296;
+pub const BTRFS_SUPER_FLAG_METADUMP: u64 = 8589934592;
+pub const BTRFS_SUPER_FLAG_METADUMP_V2: u64 = 17179869184;
+pub const BTRFS_SUPER_FLAG_CHANGING_FSID: u64 = 34359738368;
+pub const BTRFS_SUPER_FLAG_CHANGING_FSID_V2: u64 = 68719476736;
+pub const BTRFS_SUPER_FLAG_CHANGING_BG_TREE: u64 = 274877906944;
+pub const BTRFS_SUPER_FLAG_CHANGING_DATA_CSUM: u64 = 549755813888;
+pub const BTRFS_SUPER_FLAG_CHANGING_META_CSUM: u64 = 1099511627776;
+pub const BTRFS_EXTENT_FLAG_DATA: u32 = 1;
+pub const BTRFS_EXTENT_FLAG_TREE_BLOCK: u32 = 2;
+pub const BTRFS_BLOCK_FLAG_FULL_BACKREF: u32 = 256;
+pub const BTRFS_BACKREF_REV_MAX: u32 = 256;
+pub const BTRFS_BACKREF_REV_SHIFT: u32 = 56;
+pub const BTRFS_OLD_BACKREF_REV: u32 = 0;
+pub const BTRFS_MIXED_BACKREF_REV: u32 = 1;
+pub const BTRFS_EXTENT_FLAG_SUPER: u64 = 281474976710656;
+pub const BTRFS_ROOT_SUBVOL_RDONLY: u32 = 1;
+pub const BTRFS_ROOT_SUBVOL_DEAD: u64 = 281474976710656;
+pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_ALWAYS: u32 = 0;
+pub const BTRFS_DEV_REPLACE_ITEM_CONT_READING_FROM_SRCDEV_MODE_AVOID: u32 = 1;
+pub const BTRFS_BLOCK_GROUP_DATA: u32 = 1;
+pub const BTRFS_BLOCK_GROUP_SYSTEM: u32 = 2;
+pub const BTRFS_BLOCK_GROUP_METADATA: u32 = 4;
+pub const BTRFS_BLOCK_GROUP_RAID0: u32 = 8;
+pub const BTRFS_BLOCK_GROUP_RAID1: u32 = 16;
+pub const BTRFS_BLOCK_GROUP_DUP: u32 = 32;
+pub const BTRFS_BLOCK_GROUP_RAID10: u32 = 64;
+pub const BTRFS_BLOCK_GROUP_RAID5: u32 = 128;
+pub const BTRFS_BLOCK_GROUP_RAID6: u32 = 256;
+pub const BTRFS_BLOCK_GROUP_RAID1C3: u32 = 512;
+pub const BTRFS_BLOCK_GROUP_RAID1C4: u32 = 1024;
+pub const BTRFS_BLOCK_GROUP_TYPE_MASK: u32 = 7;
+pub const BTRFS_BLOCK_GROUP_PROFILE_MASK: u32 = 2040;
+pub const BTRFS_BLOCK_GROUP_RAID56_MASK: u32 = 384;
+pub const BTRFS_BLOCK_GROUP_RAID1_MASK: u32 = 1552;
+pub const BTRFS_AVAIL_ALLOC_BIT_SINGLE: u64 = 281474976710656;
+pub const BTRFS_SPACE_INFO_GLOBAL_RSV: u64 = 562949953421312;
+pub const BTRFS_EXTENDED_PROFILE_MASK: u64 = 281474976712696;
+pub const BTRFS_FREE_SPACE_USING_BITMAPS: u32 = 1;
+pub const BTRFS_QGROUP_LEVEL_SHIFT: u32 = 48;
+pub const BTRFS_QGROUP_STATUS_FLAG_ON: u32 = 1;
+pub const BTRFS_QGROUP_STATUS_FLAG_RESCAN: u32 = 2;
+pub const BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT: u32 = 4;
+pub const BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE: u32 = 8;
+pub const BTRFS_QGROUP_STATUS_FLAGS_MASK: u32 = 15;
+pub const BTRFS_QGROUP_STATUS_VERSION: u32 = 1;
+pub const BTRFS_FILE_EXTENT_INLINE: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_INLINE;
+pub const BTRFS_FILE_EXTENT_REG: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_REG;
+pub const BTRFS_FILE_EXTENT_PREALLOC: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_FILE_EXTENT_PREALLOC;
+pub const BTRFS_NR_FILE_EXTENT_TYPES: _bindgen_ty_1 = _bindgen_ty_1::BTRFS_NR_FILE_EXTENT_TYPES;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum fsconfig_command {
+FSCONFIG_SET_FLAG = 0,
+FSCONFIG_SET_STRING = 1,
+FSCONFIG_SET_BINARY = 2,
+FSCONFIG_SET_PATH = 3,
+FSCONFIG_SET_PATH_EMPTY = 4,
+FSCONFIG_SET_FD = 5,
+FSCONFIG_CMD_CREATE = 6,
+FSCONFIG_CMD_RECONFIGURE = 7,
+FSCONFIG_CMD_CREATE_EXCL = 8,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum procmap_query_flags {
+PROCMAP_QUERY_VMA_READABLE = 1,
+PROCMAP_QUERY_VMA_WRITABLE = 2,
+PROCMAP_QUERY_VMA_EXECUTABLE = 4,
+PROCMAP_QUERY_VMA_SHARED = 8,
+PROCMAP_QUERY_COVERING_OR_NEXT_VMA = 16,
+PROCMAP_QUERY_FILE_BACKED_VMA = 32,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_dev_stat_values {
+BTRFS_DEV_STAT_WRITE_ERRS = 0,
+BTRFS_DEV_STAT_READ_ERRS = 1,
+BTRFS_DEV_STAT_FLUSH_ERRS = 2,
+BTRFS_DEV_STAT_CORRUPTION_ERRS = 3,
+BTRFS_DEV_STAT_GENERATION_ERRS = 4,
+BTRFS_DEV_STAT_VALUES_MAX = 5,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_err_code {
+BTRFS_ERROR_DEV_RAID1_MIN_NOT_MET = 1,
+BTRFS_ERROR_DEV_RAID10_MIN_NOT_MET = 2,
+BTRFS_ERROR_DEV_RAID5_MIN_NOT_MET = 3,
+BTRFS_ERROR_DEV_RAID6_MIN_NOT_MET = 4,
+BTRFS_ERROR_DEV_TGT_REPLACE = 5,
+BTRFS_ERROR_DEV_MISSING_NOT_FOUND = 6,
+BTRFS_ERROR_DEV_ONLY_WRITABLE = 7,
+BTRFS_ERROR_DEV_EXCL_RUN_IN_PROGRESS = 8,
+BTRFS_ERROR_DEV_RAID1C3_MIN_NOT_MET = 9,
+BTRFS_ERROR_DEV_RAID1C4_MIN_NOT_MET = 10,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum btrfs_csum_type {
+BTRFS_CSUM_TYPE_CRC32 = 0,
+BTRFS_CSUM_TYPE_XXHASH = 1,
+BTRFS_CSUM_TYPE_SHA256 = 2,
+BTRFS_CSUM_TYPE_BLAKE2 = 3,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+BTRFS_FILE_EXTENT_INLINE = 0,
+BTRFS_FILE_EXTENT_REG = 1,
+BTRFS_FILE_EXTENT_PREALLOC = 2,
+BTRFS_NR_FILE_EXTENT_TYPES = 3,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_get_policy_ex_arg__bindgen_ty_1 {
+pub version: __u8,
+pub v1: fscrypt_policy_v1,
+pub v2: fscrypt_policy_v2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_key_specifier__bindgen_ty_1 {
+pub __reserved: [__u8; 32usize],
+pub descriptor: [__u8; 8usize],
+pub identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_vol_args_v2__bindgen_ty_1 {
+pub __bindgen_anon_1: btrfs_ioctl_vol_args_v2__bindgen_ty_1__bindgen_ty_1,
+pub unused: [__u64; 4usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_vol_args_v2__bindgen_ty_2 {
+pub name: [crate::ctypes::c_char; 4040usize],
+pub devid: __u64,
+pub subvolid: __u64,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_dev_replace_args__bindgen_ty_1 {
+pub start: btrfs_ioctl_dev_replace_start_params,
+pub status: btrfs_ioctl_dev_replace_status_params,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_balance_args__bindgen_ty_1 {
+pub usage: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_balance_args__bindgen_ty_2 {
+pub limit: __u64,
+pub __bindgen_anon_1: btrfs_balance_args__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_ioctl_defrag_range_args__bindgen_ty_1 {
+pub compress_type: __u32,
+pub compress: btrfs_ioctl_defrag_range_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_disk_balance_args__bindgen_ty_1 {
+pub usage: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union btrfs_disk_balance_args__bindgen_ty_2 {
+pub limit: __le64,
+pub __bindgen_anon_1: btrfs_disk_balance_args__bindgen_ty_2__bindgen_ty_1,
+}
+impl<T> __IncompleteArrayField<T> {
+#[inline]
+pub const fn new() -> Self {
+__IncompleteArrayField(::core::marker::PhantomData, [])
+}
+#[inline]
+pub fn as_ptr(&self) -> *const T {
+self as *const _ as *const T
+}
+#[inline]
+pub fn as_mut_ptr(&mut self) -> *mut T {
+self as *mut _ as *mut T
+}
+#[inline]
+pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+::core::slice::from_raw_parts(self.as_ptr(), len)
+}
+#[inline]
+pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+}
+}
+impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__IncompleteArrayField")
+}
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/elf_uapi.rs

@@ -0,0 +1,654 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type Elf32_Addr = __u32;
+pub type Elf32_Half = __u16;
+pub type Elf32_Off = __u32;
+pub type Elf32_Sword = __s32;
+pub type Elf32_Word = __u32;
+pub type Elf32_Versym = __u16;
+pub type Elf64_Addr = __u64;
+pub type Elf64_Half = __u16;
+pub type Elf64_SHalf = __s16;
+pub type Elf64_Off = __u64;
+pub type Elf64_Sword = __s32;
+pub type Elf64_Word = __u32;
+pub type Elf64_Xword = __u64;
+pub type Elf64_Sxword = __s64;
+pub type Elf64_Versym = __u16;
+pub type Elf32_Rel = elf32_rel;
+pub type Elf64_Rel = elf64_rel;
+pub type Elf32_Rela = elf32_rela;
+pub type Elf64_Rela = elf64_rela;
+pub type Elf32_Sym = elf32_sym;
+pub type Elf64_Sym = elf64_sym;
+pub type Elf32_Ehdr = elf32_hdr;
+pub type Elf64_Ehdr = elf64_hdr;
+pub type Elf32_Phdr = elf32_phdr;
+pub type Elf64_Phdr = elf64_phdr;
+pub type Elf32_Shdr = elf32_shdr;
+pub type Elf64_Shdr = elf64_shdr;
+pub type Elf32_Nhdr = elf32_note;
+pub type Elf64_Nhdr = elf64_note;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Elf32_Dyn {
+pub d_tag: Elf32_Sword,
+pub d_un: Elf32_Dyn__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Elf64_Dyn {
+pub d_tag: Elf64_Sxword,
+pub d_un: Elf64_Dyn__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_rel {
+pub r_offset: Elf32_Addr,
+pub r_info: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_rel {
+pub r_offset: Elf64_Addr,
+pub r_info: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_rela {
+pub r_offset: Elf32_Addr,
+pub r_info: Elf32_Word,
+pub r_addend: Elf32_Sword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_rela {
+pub r_offset: Elf64_Addr,
+pub r_info: Elf64_Xword,
+pub r_addend: Elf64_Sxword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_sym {
+pub st_name: Elf32_Word,
+pub st_value: Elf32_Addr,
+pub st_size: Elf32_Word,
+pub st_info: crate::ctypes::c_uchar,
+pub st_other: crate::ctypes::c_uchar,
+pub st_shndx: Elf32_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_sym {
+pub st_name: Elf64_Word,
+pub st_info: crate::ctypes::c_uchar,
+pub st_other: crate::ctypes::c_uchar,
+pub st_shndx: Elf64_Half,
+pub st_value: Elf64_Addr,
+pub st_size: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_hdr {
+pub e_ident: [crate::ctypes::c_uchar; 16usize],
+pub e_type: Elf32_Half,
+pub e_machine: Elf32_Half,
+pub e_version: Elf32_Word,
+pub e_entry: Elf32_Addr,
+pub e_phoff: Elf32_Off,
+pub e_shoff: Elf32_Off,
+pub e_flags: Elf32_Word,
+pub e_ehsize: Elf32_Half,
+pub e_phentsize: Elf32_Half,
+pub e_phnum: Elf32_Half,
+pub e_shentsize: Elf32_Half,
+pub e_shnum: Elf32_Half,
+pub e_shstrndx: Elf32_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_hdr {
+pub e_ident: [crate::ctypes::c_uchar; 16usize],
+pub e_type: Elf64_Half,
+pub e_machine: Elf64_Half,
+pub e_version: Elf64_Word,
+pub e_entry: Elf64_Addr,
+pub e_phoff: Elf64_Off,
+pub e_shoff: Elf64_Off,
+pub e_flags: Elf64_Word,
+pub e_ehsize: Elf64_Half,
+pub e_phentsize: Elf64_Half,
+pub e_phnum: Elf64_Half,
+pub e_shentsize: Elf64_Half,
+pub e_shnum: Elf64_Half,
+pub e_shstrndx: Elf64_Half,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_phdr {
+pub p_type: Elf32_Word,
+pub p_offset: Elf32_Off,
+pub p_vaddr: Elf32_Addr,
+pub p_paddr: Elf32_Addr,
+pub p_filesz: Elf32_Word,
+pub p_memsz: Elf32_Word,
+pub p_flags: Elf32_Word,
+pub p_align: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_phdr {
+pub p_type: Elf64_Word,
+pub p_flags: Elf64_Word,
+pub p_offset: Elf64_Off,
+pub p_vaddr: Elf64_Addr,
+pub p_paddr: Elf64_Addr,
+pub p_filesz: Elf64_Xword,
+pub p_memsz: Elf64_Xword,
+pub p_align: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_shdr {
+pub sh_name: Elf32_Word,
+pub sh_type: Elf32_Word,
+pub sh_flags: Elf32_Word,
+pub sh_addr: Elf32_Addr,
+pub sh_offset: Elf32_Off,
+pub sh_size: Elf32_Word,
+pub sh_link: Elf32_Word,
+pub sh_info: Elf32_Word,
+pub sh_addralign: Elf32_Word,
+pub sh_entsize: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_shdr {
+pub sh_name: Elf64_Word,
+pub sh_type: Elf64_Word,
+pub sh_flags: Elf64_Xword,
+pub sh_addr: Elf64_Addr,
+pub sh_offset: Elf64_Off,
+pub sh_size: Elf64_Xword,
+pub sh_link: Elf64_Word,
+pub sh_info: Elf64_Word,
+pub sh_addralign: Elf64_Xword,
+pub sh_entsize: Elf64_Xword,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf32_note {
+pub n_namesz: Elf32_Word,
+pub n_descsz: Elf32_Word,
+pub n_type: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct elf64_note {
+pub n_namesz: Elf64_Word,
+pub n_descsz: Elf64_Word,
+pub n_type: Elf64_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf32_Verdef {
+pub vd_version: Elf32_Half,
+pub vd_flags: Elf32_Half,
+pub vd_ndx: Elf32_Half,
+pub vd_cnt: Elf32_Half,
+pub vd_hash: Elf32_Word,
+pub vd_aux: Elf32_Word,
+pub vd_next: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf64_Verdef {
+pub vd_version: Elf64_Half,
+pub vd_flags: Elf64_Half,
+pub vd_ndx: Elf64_Half,
+pub vd_cnt: Elf64_Half,
+pub vd_hash: Elf64_Word,
+pub vd_aux: Elf64_Word,
+pub vd_next: Elf64_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf32_Verdaux {
+pub vda_name: Elf32_Word,
+pub vda_next: Elf32_Word,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct Elf64_Verdaux {
+pub vda_name: Elf64_Word,
+pub vda_next: Elf64_Word,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const EM_NONE: u32 = 0;
+pub const EM_M32: u32 = 1;
+pub const EM_SPARC: u32 = 2;
+pub const EM_386: u32 = 3;
+pub const EM_68K: u32 = 4;
+pub const EM_88K: u32 = 5;
+pub const EM_486: u32 = 6;
+pub const EM_860: u32 = 7;
+pub const EM_MIPS: u32 = 8;
+pub const EM_MIPS_RS3_LE: u32 = 10;
+pub const EM_MIPS_RS4_BE: u32 = 10;
+pub const EM_PARISC: u32 = 15;
+pub const EM_SPARC32PLUS: u32 = 18;
+pub const EM_PPC: u32 = 20;
+pub const EM_PPC64: u32 = 21;
+pub const EM_SPU: u32 = 23;
+pub const EM_ARM: u32 = 40;
+pub const EM_SH: u32 = 42;
+pub const EM_SPARCV9: u32 = 43;
+pub const EM_H8_300: u32 = 46;
+pub const EM_IA_64: u32 = 50;
+pub const EM_X86_64: u32 = 62;
+pub const EM_S390: u32 = 22;
+pub const EM_CRIS: u32 = 76;
+pub const EM_M32R: u32 = 88;
+pub const EM_MN10300: u32 = 89;
+pub const EM_OPENRISC: u32 = 92;
+pub const EM_ARCOMPACT: u32 = 93;
+pub const EM_XTENSA: u32 = 94;
+pub const EM_BLACKFIN: u32 = 106;
+pub const EM_UNICORE: u32 = 110;
+pub const EM_ALTERA_NIOS2: u32 = 113;
+pub const EM_TI_C6000: u32 = 140;
+pub const EM_HEXAGON: u32 = 164;
+pub const EM_NDS32: u32 = 167;
+pub const EM_AARCH64: u32 = 183;
+pub const EM_TILEPRO: u32 = 188;
+pub const EM_MICROBLAZE: u32 = 189;
+pub const EM_TILEGX: u32 = 191;
+pub const EM_ARCV2: u32 = 195;
+pub const EM_RISCV: u32 = 243;
+pub const EM_BPF: u32 = 247;
+pub const EM_CSKY: u32 = 252;
+pub const EM_LOONGARCH: u32 = 258;
+pub const EM_FRV: u32 = 21569;
+pub const EM_ALPHA: u32 = 36902;
+pub const EM_CYGNUS_M32R: u32 = 36929;
+pub const EM_S390_OLD: u32 = 41872;
+pub const EM_CYGNUS_MN10300: u32 = 48879;
+pub const PT_NULL: u32 = 0;
+pub const PT_LOAD: u32 = 1;
+pub const PT_DYNAMIC: u32 = 2;
+pub const PT_INTERP: u32 = 3;
+pub const PT_NOTE: u32 = 4;
+pub const PT_SHLIB: u32 = 5;
+pub const PT_PHDR: u32 = 6;
+pub const PT_TLS: u32 = 7;
+pub const PT_LOOS: u32 = 1610612736;
+pub const PT_HIOS: u32 = 1879048191;
+pub const PT_LOPROC: u32 = 1879048192;
+pub const PT_HIPROC: u32 = 2147483647;
+pub const PT_GNU_EH_FRAME: u32 = 1685382480;
+pub const PT_GNU_STACK: u32 = 1685382481;
+pub const PT_GNU_RELRO: u32 = 1685382482;
+pub const PT_GNU_PROPERTY: u32 = 1685382483;
+pub const PT_AARCH64_MEMTAG_MTE: u32 = 1879048194;
+pub const PN_XNUM: u32 = 65535;
+pub const ET_NONE: u32 = 0;
+pub const ET_REL: u32 = 1;
+pub const ET_EXEC: u32 = 2;
+pub const ET_DYN: u32 = 3;
+pub const ET_CORE: u32 = 4;
+pub const ET_LOPROC: u32 = 65280;
+pub const ET_HIPROC: u32 = 65535;
+pub const DT_NULL: u32 = 0;
+pub const DT_NEEDED: u32 = 1;
+pub const DT_PLTRELSZ: u32 = 2;
+pub const DT_PLTGOT: u32 = 3;
+pub const DT_HASH: u32 = 4;
+pub const DT_STRTAB: u32 = 5;
+pub const DT_SYMTAB: u32 = 6;
+pub const DT_RELA: u32 = 7;
+pub const DT_RELASZ: u32 = 8;
+pub const DT_RELAENT: u32 = 9;
+pub const DT_STRSZ: u32 = 10;
+pub const DT_SYMENT: u32 = 11;
+pub const DT_INIT: u32 = 12;
+pub const DT_FINI: u32 = 13;
+pub const DT_SONAME: u32 = 14;
+pub const DT_RPATH: u32 = 15;
+pub const DT_SYMBOLIC: u32 = 16;
+pub const DT_REL: u32 = 17;
+pub const DT_RELSZ: u32 = 18;
+pub const DT_RELENT: u32 = 19;
+pub const DT_PLTREL: u32 = 20;
+pub const DT_DEBUG: u32 = 21;
+pub const DT_TEXTREL: u32 = 22;
+pub const DT_JMPREL: u32 = 23;
+pub const DT_ENCODING: u32 = 32;
+pub const OLD_DT_LOOS: u32 = 1610612736;
+pub const DT_LOOS: u32 = 1610612749;
+pub const DT_HIOS: u32 = 1879044096;
+pub const DT_VALRNGLO: u32 = 1879047424;
+pub const DT_VALRNGHI: u32 = 1879047679;
+pub const DT_ADDRRNGLO: u32 = 1879047680;
+pub const DT_GNU_HASH: u32 = 1879047925;
+pub const DT_ADDRRNGHI: u32 = 1879047935;
+pub const DT_VERSYM: u32 = 1879048176;
+pub const DT_RELACOUNT: u32 = 1879048185;
+pub const DT_RELCOUNT: u32 = 1879048186;
+pub const DT_FLAGS_1: u32 = 1879048187;
+pub const DT_VERDEF: u32 = 1879048188;
+pub const DT_VERDEFNUM: u32 = 1879048189;
+pub const DT_VERNEED: u32 = 1879048190;
+pub const DT_VERNEEDNUM: u32 = 1879048191;
+pub const OLD_DT_HIOS: u32 = 1879048191;
+pub const DT_LOPROC: u32 = 1879048192;
+pub const DT_HIPROC: u32 = 2147483647;
+pub const STB_LOCAL: u32 = 0;
+pub const STB_GLOBAL: u32 = 1;
+pub const STB_WEAK: u32 = 2;
+pub const STN_UNDEF: u32 = 0;
+pub const STT_NOTYPE: u32 = 0;
+pub const STT_OBJECT: u32 = 1;
+pub const STT_FUNC: u32 = 2;
+pub const STT_SECTION: u32 = 3;
+pub const STT_FILE: u32 = 4;
+pub const STT_COMMON: u32 = 5;
+pub const STT_TLS: u32 = 6;
+pub const VER_FLG_BASE: u32 = 1;
+pub const VER_FLG_WEAK: u32 = 2;
+pub const EI_NIDENT: u32 = 16;
+pub const PF_R: u32 = 4;
+pub const PF_W: u32 = 2;
+pub const PF_X: u32 = 1;
+pub const SHT_NULL: u32 = 0;
+pub const SHT_PROGBITS: u32 = 1;
+pub const SHT_SYMTAB: u32 = 2;
+pub const SHT_STRTAB: u32 = 3;
+pub const SHT_RELA: u32 = 4;
+pub const SHT_HASH: u32 = 5;
+pub const SHT_DYNAMIC: u32 = 6;
+pub const SHT_NOTE: u32 = 7;
+pub const SHT_NOBITS: u32 = 8;
+pub const SHT_REL: u32 = 9;
+pub const SHT_SHLIB: u32 = 10;
+pub const SHT_DYNSYM: u32 = 11;
+pub const SHT_NUM: u32 = 12;
+pub const SHT_LOPROC: u32 = 1879048192;
+pub const SHT_HIPROC: u32 = 2147483647;
+pub const SHT_LOUSER: u32 = 2147483648;
+pub const SHT_HIUSER: u32 = 4294967295;
+pub const SHF_WRITE: u32 = 1;
+pub const SHF_ALLOC: u32 = 2;
+pub const SHF_EXECINSTR: u32 = 4;
+pub const SHF_MERGE: u32 = 16;
+pub const SHF_STRINGS: u32 = 32;
+pub const SHF_INFO_LINK: u32 = 64;
+pub const SHF_LINK_ORDER: u32 = 128;
+pub const SHF_OS_NONCONFORMING: u32 = 256;
+pub const SHF_GROUP: u32 = 512;
+pub const SHF_TLS: u32 = 1024;
+pub const SHF_RELA_LIVEPATCH: u32 = 1048576;
+pub const SHF_RO_AFTER_INIT: u32 = 2097152;
+pub const SHF_ORDERED: u32 = 67108864;
+pub const SHF_EXCLUDE: u32 = 134217728;
+pub const SHF_MASKOS: u32 = 267386880;
+pub const SHF_MASKPROC: u32 = 4026531840;
+pub const SHN_UNDEF: u32 = 0;
+pub const SHN_LORESERVE: u32 = 65280;
+pub const SHN_LOPROC: u32 = 65280;
+pub const SHN_HIPROC: u32 = 65311;
+pub const SHN_LIVEPATCH: u32 = 65312;
+pub const SHN_ABS: u32 = 65521;
+pub const SHN_COMMON: u32 = 65522;
+pub const SHN_HIRESERVE: u32 = 65535;
+pub const EI_MAG0: u32 = 0;
+pub const EI_MAG1: u32 = 1;
+pub const EI_MAG2: u32 = 2;
+pub const EI_MAG3: u32 = 3;
+pub const EI_CLASS: u32 = 4;
+pub const EI_DATA: u32 = 5;
+pub const EI_VERSION: u32 = 6;
+pub const EI_OSABI: u32 = 7;
+pub const EI_PAD: u32 = 8;
+pub const ELFMAG0: u32 = 127;
+pub const ELFMAG1: u8 = 69u8;
+pub const ELFMAG2: u8 = 76u8;
+pub const ELFMAG3: u8 = 70u8;
+pub const ELFMAG: &[u8; 5] = b"\x7FELF\0";
+pub const SELFMAG: u32 = 4;
+pub const ELFCLASSNONE: u32 = 0;
+pub const ELFCLASS32: u32 = 1;
+pub const ELFCLASS64: u32 = 2;
+pub const ELFCLASSNUM: u32 = 3;
+pub const ELFDATANONE: u32 = 0;
+pub const ELFDATA2LSB: u32 = 1;
+pub const ELFDATA2MSB: u32 = 2;
+pub const EV_NONE: u32 = 0;
+pub const EV_CURRENT: u32 = 1;
+pub const EV_NUM: u32 = 2;
+pub const ELFOSABI_NONE: u32 = 0;
+pub const ELFOSABI_LINUX: u32 = 3;
+pub const ELF_OSABI: u32 = 0;
+pub const NN_GNU_PROPERTY_TYPE_0: &[u8; 4] = b"GNU\0";
+pub const NT_GNU_PROPERTY_TYPE_0: u32 = 5;
+pub const NN_PRSTATUS: &[u8; 5] = b"CORE\0";
+pub const NT_PRSTATUS: u32 = 1;
+pub const NN_PRFPREG: &[u8; 5] = b"CORE\0";
+pub const NT_PRFPREG: u32 = 2;
+pub const NN_PRPSINFO: &[u8; 5] = b"CORE\0";
+pub const NT_PRPSINFO: u32 = 3;
+pub const NN_TASKSTRUCT: &[u8; 5] = b"CORE\0";
+pub const NT_TASKSTRUCT: u32 = 4;
+pub const NN_AUXV: &[u8; 5] = b"CORE\0";
+pub const NT_AUXV: u32 = 6;
+pub const NN_SIGINFO: &[u8; 5] = b"CORE\0";
+pub const NT_SIGINFO: u32 = 1397311305;
+pub const NN_FILE: &[u8; 5] = b"CORE\0";
+pub const NT_FILE: u32 = 1179208773;
+pub const NN_PRXFPREG: &[u8; 6] = b"LINUX\0";
+pub const NT_PRXFPREG: u32 = 1189489535;
+pub const NN_PPC_VMX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_VMX: u32 = 256;
+pub const NN_PPC_SPE: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_SPE: u32 = 257;
+pub const NN_PPC_VSX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_VSX: u32 = 258;
+pub const NN_PPC_TAR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TAR: u32 = 259;
+pub const NN_PPC_PPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PPR: u32 = 260;
+pub const NN_PPC_DSCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_DSCR: u32 = 261;
+pub const NN_PPC_EBB: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_EBB: u32 = 262;
+pub const NN_PPC_PMU: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PMU: u32 = 263;
+pub const NN_PPC_TM_CGPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CGPR: u32 = 264;
+pub const NN_PPC_TM_CFPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CFPR: u32 = 265;
+pub const NN_PPC_TM_CVMX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CVMX: u32 = 266;
+pub const NN_PPC_TM_CVSX: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CVSX: u32 = 267;
+pub const NN_PPC_TM_SPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_SPR: u32 = 268;
+pub const NN_PPC_TM_CTAR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CTAR: u32 = 269;
+pub const NN_PPC_TM_CPPR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CPPR: u32 = 270;
+pub const NN_PPC_TM_CDSCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_TM_CDSCR: u32 = 271;
+pub const NN_PPC_PKEY: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_PKEY: u32 = 272;
+pub const NN_PPC_DEXCR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_DEXCR: u32 = 273;
+pub const NN_PPC_HASHKEYR: &[u8; 6] = b"LINUX\0";
+pub const NT_PPC_HASHKEYR: u32 = 274;
+pub const NN_386_TLS: &[u8; 6] = b"LINUX\0";
+pub const NT_386_TLS: u32 = 512;
+pub const NN_386_IOPERM: &[u8; 6] = b"LINUX\0";
+pub const NT_386_IOPERM: u32 = 513;
+pub const NN_X86_XSTATE: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_XSTATE: u32 = 514;
+pub const NN_X86_SHSTK: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_SHSTK: u32 = 516;
+pub const NN_X86_XSAVE_LAYOUT: &[u8; 6] = b"LINUX\0";
+pub const NT_X86_XSAVE_LAYOUT: u32 = 517;
+pub const NN_S390_HIGH_GPRS: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_HIGH_GPRS: u32 = 768;
+pub const NN_S390_TIMER: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TIMER: u32 = 769;
+pub const NN_S390_TODCMP: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TODCMP: u32 = 770;
+pub const NN_S390_TODPREG: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TODPREG: u32 = 771;
+pub const NN_S390_CTRS: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_CTRS: u32 = 772;
+pub const NN_S390_PREFIX: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_PREFIX: u32 = 773;
+pub const NN_S390_LAST_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_LAST_BREAK: u32 = 774;
+pub const NN_S390_SYSTEM_CALL: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_SYSTEM_CALL: u32 = 775;
+pub const NN_S390_TDB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_TDB: u32 = 776;
+pub const NN_S390_VXRS_LOW: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_VXRS_LOW: u32 = 777;
+pub const NN_S390_VXRS_HIGH: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_VXRS_HIGH: u32 = 778;
+pub const NN_S390_GS_CB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_GS_CB: u32 = 779;
+pub const NN_S390_GS_BC: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_GS_BC: u32 = 780;
+pub const NN_S390_RI_CB: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_RI_CB: u32 = 781;
+pub const NN_S390_PV_CPU_DATA: &[u8; 6] = b"LINUX\0";
+pub const NT_S390_PV_CPU_DATA: u32 = 782;
+pub const NN_ARM_VFP: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_VFP: u32 = 1024;
+pub const NN_ARM_TLS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_TLS: u32 = 1025;
+pub const NN_ARM_HW_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_HW_BREAK: u32 = 1026;
+pub const NN_ARM_HW_WATCH: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_HW_WATCH: u32 = 1027;
+pub const NN_ARM_SYSTEM_CALL: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SYSTEM_CALL: u32 = 1028;
+pub const NN_ARM_SVE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SVE: u32 = 1029;
+pub const NN_ARM_PAC_MASK: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PAC_MASK: u32 = 1030;
+pub const NN_ARM_PACA_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PACA_KEYS: u32 = 1031;
+pub const NN_ARM_PACG_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PACG_KEYS: u32 = 1032;
+pub const NN_ARM_TAGGED_ADDR_CTRL: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_TAGGED_ADDR_CTRL: u32 = 1033;
+pub const NN_ARM_PAC_ENABLED_KEYS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_PAC_ENABLED_KEYS: u32 = 1034;
+pub const NN_ARM_SSVE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_SSVE: u32 = 1035;
+pub const NN_ARM_ZA: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_ZA: u32 = 1036;
+pub const NN_ARM_ZT: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_ZT: u32 = 1037;
+pub const NN_ARM_FPMR: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_FPMR: u32 = 1038;
+pub const NN_ARM_POE: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_POE: u32 = 1039;
+pub const NN_ARM_GCS: &[u8; 6] = b"LINUX\0";
+pub const NT_ARM_GCS: u32 = 1040;
+pub const NN_ARC_V2: &[u8; 6] = b"LINUX\0";
+pub const NT_ARC_V2: u32 = 1536;
+pub const NN_VMCOREDD: &[u8; 6] = b"LINUX\0";
+pub const NT_VMCOREDD: u32 = 1792;
+pub const NN_MIPS_DSP: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_DSP: u32 = 2048;
+pub const NN_MIPS_FP_MODE: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_FP_MODE: u32 = 2049;
+pub const NN_MIPS_MSA: &[u8; 6] = b"LINUX\0";
+pub const NT_MIPS_MSA: u32 = 2050;
+pub const NN_RISCV_CSR: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_CSR: u32 = 2304;
+pub const NN_RISCV_VECTOR: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_VECTOR: u32 = 2305;
+pub const NN_RISCV_TAGGED_ADDR_CTRL: &[u8; 6] = b"LINUX\0";
+pub const NT_RISCV_TAGGED_ADDR_CTRL: u32 = 2306;
+pub const NN_LOONGARCH_CPUCFG: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_CPUCFG: u32 = 2560;
+pub const NN_LOONGARCH_CSR: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_CSR: u32 = 2561;
+pub const NN_LOONGARCH_LSX: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LSX: u32 = 2562;
+pub const NN_LOONGARCH_LASX: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LASX: u32 = 2563;
+pub const NN_LOONGARCH_LBT: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_LBT: u32 = 2564;
+pub const NN_LOONGARCH_HW_BREAK: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_HW_BREAK: u32 = 2565;
+pub const NN_LOONGARCH_HW_WATCH: &[u8; 6] = b"LINUX\0";
+pub const NT_LOONGARCH_HW_WATCH: u32 = 2566;
+pub const GNU_PROPERTY_AARCH64_FEATURE_1_AND: u32 = 3221225472;
+pub const GNU_PROPERTY_AARCH64_FEATURE_1_BTI: u32 = 1;
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Elf32_Dyn__bindgen_ty_1 {
+pub d_val: Elf32_Sword,
+pub d_ptr: Elf32_Addr,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union Elf64_Dyn__bindgen_ty_1 {
+pub d_val: Elf64_Xword,
+pub d_ptr: Elf64_Addr,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/errno.rs

@@ -0,0 +1,135 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const EPERM: u32 = 1;
+pub const ENOENT: u32 = 2;
+pub const ESRCH: u32 = 3;
+pub const EINTR: u32 = 4;
+pub const EIO: u32 = 5;
+pub const ENXIO: u32 = 6;
+pub const E2BIG: u32 = 7;
+pub const ENOEXEC: u32 = 8;
+pub const EBADF: u32 = 9;
+pub const ECHILD: u32 = 10;
+pub const EAGAIN: u32 = 11;
+pub const ENOMEM: u32 = 12;
+pub const EACCES: u32 = 13;
+pub const EFAULT: u32 = 14;
+pub const ENOTBLK: u32 = 15;
+pub const EBUSY: u32 = 16;
+pub const EEXIST: u32 = 17;
+pub const EXDEV: u32 = 18;
+pub const ENODEV: u32 = 19;
+pub const ENOTDIR: u32 = 20;
+pub const EISDIR: u32 = 21;
+pub const EINVAL: u32 = 22;
+pub const ENFILE: u32 = 23;
+pub const EMFILE: u32 = 24;
+pub const ENOTTY: u32 = 25;
+pub const ETXTBSY: u32 = 26;
+pub const EFBIG: u32 = 27;
+pub const ENOSPC: u32 = 28;
+pub const ESPIPE: u32 = 29;
+pub const EROFS: u32 = 30;
+pub const EMLINK: u32 = 31;
+pub const EPIPE: u32 = 32;
+pub const EDOM: u32 = 33;
+pub const ERANGE: u32 = 34;
+pub const EDEADLK: u32 = 35;
+pub const ENAMETOOLONG: u32 = 36;
+pub const ENOLCK: u32 = 37;
+pub const ENOSYS: u32 = 38;
+pub const ENOTEMPTY: u32 = 39;
+pub const ELOOP: u32 = 40;
+pub const EWOULDBLOCK: u32 = 11;
+pub const ENOMSG: u32 = 42;
+pub const EIDRM: u32 = 43;
+pub const ECHRNG: u32 = 44;
+pub const EL2NSYNC: u32 = 45;
+pub const EL3HLT: u32 = 46;
+pub const EL3RST: u32 = 47;
+pub const ELNRNG: u32 = 48;
+pub const EUNATCH: u32 = 49;
+pub const ENOCSI: u32 = 50;
+pub const EL2HLT: u32 = 51;
+pub const EBADE: u32 = 52;
+pub const EBADR: u32 = 53;
+pub const EXFULL: u32 = 54;
+pub const ENOANO: u32 = 55;
+pub const EBADRQC: u32 = 56;
+pub const EBADSLT: u32 = 57;
+pub const EDEADLOCK: u32 = 35;
+pub const EBFONT: u32 = 59;
+pub const ENOSTR: u32 = 60;
+pub const ENODATA: u32 = 61;
+pub const ETIME: u32 = 62;
+pub const ENOSR: u32 = 63;
+pub const ENONET: u32 = 64;
+pub const ENOPKG: u32 = 65;
+pub const EREMOTE: u32 = 66;
+pub const ENOLINK: u32 = 67;
+pub const EADV: u32 = 68;
+pub const ESRMNT: u32 = 69;
+pub const ECOMM: u32 = 70;
+pub const EPROTO: u32 = 71;
+pub const EMULTIHOP: u32 = 72;
+pub const EDOTDOT: u32 = 73;
+pub const EBADMSG: u32 = 74;
+pub const EOVERFLOW: u32 = 75;
+pub const ENOTUNIQ: u32 = 76;
+pub const EBADFD: u32 = 77;
+pub const EREMCHG: u32 = 78;
+pub const ELIBACC: u32 = 79;
+pub const ELIBBAD: u32 = 80;
+pub const ELIBSCN: u32 = 81;
+pub const ELIBMAX: u32 = 82;
+pub const ELIBEXEC: u32 = 83;
+pub const EILSEQ: u32 = 84;
+pub const ERESTART: u32 = 85;
+pub const ESTRPIPE: u32 = 86;
+pub const EUSERS: u32 = 87;
+pub const ENOTSOCK: u32 = 88;
+pub const EDESTADDRREQ: u32 = 89;
+pub const EMSGSIZE: u32 = 90;
+pub const EPROTOTYPE: u32 = 91;
+pub const ENOPROTOOPT: u32 = 92;
+pub const EPROTONOSUPPORT: u32 = 93;
+pub const ESOCKTNOSUPPORT: u32 = 94;
+pub const EOPNOTSUPP: u32 = 95;
+pub const EPFNOSUPPORT: u32 = 96;
+pub const EAFNOSUPPORT: u32 = 97;
+pub const EADDRINUSE: u32 = 98;
+pub const EADDRNOTAVAIL: u32 = 99;
+pub const ENETDOWN: u32 = 100;
+pub const ENETUNREACH: u32 = 101;
+pub const ENETRESET: u32 = 102;
+pub const ECONNABORTED: u32 = 103;
+pub const ECONNRESET: u32 = 104;
+pub const ENOBUFS: u32 = 105;
+pub const EISCONN: u32 = 106;
+pub const ENOTCONN: u32 = 107;
+pub const ESHUTDOWN: u32 = 108;
+pub const ETOOMANYREFS: u32 = 109;
+pub const ETIMEDOUT: u32 = 110;
+pub const ECONNREFUSED: u32 = 111;
+pub const EHOSTDOWN: u32 = 112;
+pub const EHOSTUNREACH: u32 = 113;
+pub const EALREADY: u32 = 114;
+pub const EINPROGRESS: u32 = 115;
+pub const ESTALE: u32 = 116;
+pub const EUCLEAN: u32 = 117;
+pub const ENOTNAM: u32 = 118;
+pub const ENAVAIL: u32 = 119;
+pub const EISNAM: u32 = 120;
+pub const EREMOTEIO: u32 = 121;
+pub const EDQUOT: u32 = 122;
+pub const ENOMEDIUM: u32 = 123;
+pub const EMEDIUMTYPE: u32 = 124;
+pub const ECANCELED: u32 = 125;
+pub const ENOKEY: u32 = 126;
+pub const EKEYEXPIRED: u32 = 127;
+pub const EKEYREVOKED: u32 = 128;
+pub const EKEYREJECTED: u32 = 129;
+pub const EOWNERDEAD: u32 = 130;
+pub const ENOTRECOVERABLE: u32 = 131;
+pub const ERFKILL: u32 = 132;
+pub const EHWPOISON: u32 = 133;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/if_ether.rs

@@ -0,0 +1,170 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct ethhdr {
+pub h_dest: [crate::ctypes::c_uchar; 6usize],
+pub h_source: [crate::ctypes::c_uchar; 6usize],
+pub h_proto: __be16,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const ETH_ALEN: u32 = 6;
+pub const ETH_TLEN: u32 = 2;
+pub const ETH_HLEN: u32 = 14;
+pub const ETH_ZLEN: u32 = 60;
+pub const ETH_DATA_LEN: u32 = 1500;
+pub const ETH_FRAME_LEN: u32 = 1514;
+pub const ETH_FCS_LEN: u32 = 4;
+pub const ETH_MIN_MTU: u32 = 68;
+pub const ETH_MAX_MTU: u32 = 65535;
+pub const ETH_P_LOOP: u32 = 96;
+pub const ETH_P_PUP: u32 = 512;
+pub const ETH_P_PUPAT: u32 = 513;
+pub const ETH_P_TSN: u32 = 8944;
+pub const ETH_P_ERSPAN2: u32 = 8939;
+pub const ETH_P_IP: u32 = 2048;
+pub const ETH_P_X25: u32 = 2053;
+pub const ETH_P_ARP: u32 = 2054;
+pub const ETH_P_BPQ: u32 = 2303;
+pub const ETH_P_IEEEPUP: u32 = 2560;
+pub const ETH_P_IEEEPUPAT: u32 = 2561;
+pub const ETH_P_BATMAN: u32 = 17157;
+pub const ETH_P_DEC: u32 = 24576;
+pub const ETH_P_DNA_DL: u32 = 24577;
+pub const ETH_P_DNA_RC: u32 = 24578;
+pub const ETH_P_DNA_RT: u32 = 24579;
+pub const ETH_P_LAT: u32 = 24580;
+pub const ETH_P_DIAG: u32 = 24581;
+pub const ETH_P_CUST: u32 = 24582;
+pub const ETH_P_SCA: u32 = 24583;
+pub const ETH_P_TEB: u32 = 25944;
+pub const ETH_P_RARP: u32 = 32821;
+pub const ETH_P_ATALK: u32 = 32923;
+pub const ETH_P_AARP: u32 = 33011;
+pub const ETH_P_8021Q: u32 = 33024;
+pub const ETH_P_ERSPAN: u32 = 35006;
+pub const ETH_P_IPX: u32 = 33079;
+pub const ETH_P_IPV6: u32 = 34525;
+pub const ETH_P_PAUSE: u32 = 34824;
+pub const ETH_P_SLOW: u32 = 34825;
+pub const ETH_P_WCCP: u32 = 34878;
+pub const ETH_P_MPLS_UC: u32 = 34887;
+pub const ETH_P_MPLS_MC: u32 = 34888;
+pub const ETH_P_ATMMPOA: u32 = 34892;
+pub const ETH_P_PPP_DISC: u32 = 34915;
+pub const ETH_P_PPP_SES: u32 = 34916;
+pub const ETH_P_LINK_CTL: u32 = 34924;
+pub const ETH_P_ATMFATE: u32 = 34948;
+pub const ETH_P_PAE: u32 = 34958;
+pub const ETH_P_PROFINET: u32 = 34962;
+pub const ETH_P_REALTEK: u32 = 34969;
+pub const ETH_P_AOE: u32 = 34978;
+pub const ETH_P_ETHERCAT: u32 = 34980;
+pub const ETH_P_8021AD: u32 = 34984;
+pub const ETH_P_802_EX1: u32 = 34997;
+pub const ETH_P_PREAUTH: u32 = 35015;
+pub const ETH_P_TIPC: u32 = 35018;
+pub const ETH_P_LLDP: u32 = 35020;
+pub const ETH_P_MRP: u32 = 35043;
+pub const ETH_P_MACSEC: u32 = 35045;
+pub const ETH_P_8021AH: u32 = 35047;
+pub const ETH_P_MVRP: u32 = 35061;
+pub const ETH_P_1588: u32 = 35063;
+pub const ETH_P_NCSI: u32 = 35064;
+pub const ETH_P_PRP: u32 = 35067;
+pub const ETH_P_CFM: u32 = 35074;
+pub const ETH_P_FCOE: u32 = 35078;
+pub const ETH_P_IBOE: u32 = 35093;
+pub const ETH_P_TDLS: u32 = 35085;
+pub const ETH_P_FIP: u32 = 35092;
+pub const ETH_P_80221: u32 = 35095;
+pub const ETH_P_HSR: u32 = 35119;
+pub const ETH_P_NSH: u32 = 35151;
+pub const ETH_P_LOOPBACK: u32 = 36864;
+pub const ETH_P_QINQ1: u32 = 37120;
+pub const ETH_P_QINQ2: u32 = 37376;
+pub const ETH_P_QINQ3: u32 = 37632;
+pub const ETH_P_EDSA: u32 = 56026;
+pub const ETH_P_DSA_8021Q: u32 = 56027;
+pub const ETH_P_DSA_A5PSW: u32 = 57345;
+pub const ETH_P_IFE: u32 = 60734;
+pub const ETH_P_AF_IUCV: u32 = 64507;
+pub const ETH_P_802_3_MIN: u32 = 1536;
+pub const ETH_P_802_3: u32 = 1;
+pub const ETH_P_AX25: u32 = 2;
+pub const ETH_P_ALL: u32 = 3;
+pub const ETH_P_802_2: u32 = 4;
+pub const ETH_P_SNAP: u32 = 5;
+pub const ETH_P_DDCMP: u32 = 6;
+pub const ETH_P_WAN_PPP: u32 = 7;
+pub const ETH_P_PPP_MP: u32 = 8;
+pub const ETH_P_LOCALTALK: u32 = 9;
+pub const ETH_P_CAN: u32 = 12;
+pub const ETH_P_CANFD: u32 = 13;
+pub const ETH_P_CANXL: u32 = 14;
+pub const ETH_P_PPPTALK: u32 = 16;
+pub const ETH_P_TR_802_2: u32 = 17;
+pub const ETH_P_MOBITEX: u32 = 21;
+pub const ETH_P_CONTROL: u32 = 22;
+pub const ETH_P_IRDA: u32 = 23;
+pub const ETH_P_ECONET: u32 = 24;
+pub const ETH_P_HDLC: u32 = 25;
+pub const ETH_P_ARCNET: u32 = 26;
+pub const ETH_P_DSA: u32 = 27;
+pub const ETH_P_TRAILER: u32 = 28;
+pub const ETH_P_PHONET: u32 = 245;
+pub const ETH_P_IEEE802154: u32 = 246;
+pub const ETH_P_CAIF: u32 = 247;
+pub const ETH_P_XDSA: u32 = 248;
+pub const ETH_P_MAP: u32 = 249;
+pub const ETH_P_MCTP: u32 = 250;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/if_packet.rs

@@ -0,0 +1,311 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_pkt {
+pub spkt_family: crate::ctypes::c_ushort,
+pub spkt_device: [crate::ctypes::c_uchar; 14usize],
+pub spkt_protocol: __be16,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct sockaddr_ll {
+pub sll_family: crate::ctypes::c_ushort,
+pub sll_protocol: __be16,
+pub sll_ifindex: crate::ctypes::c_int,
+pub sll_hatype: crate::ctypes::c_ushort,
+pub sll_pkttype: crate::ctypes::c_uchar,
+pub sll_halen: crate::ctypes::c_uchar,
+pub sll_addr: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_stats {
+pub tp_packets: crate::ctypes::c_uint,
+pub tp_drops: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_stats_v3 {
+pub tp_packets: crate::ctypes::c_uint,
+pub tp_drops: crate::ctypes::c_uint,
+pub tp_freeze_q_cnt: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_rollover_stats {
+pub tp_all: __u64,
+pub tp_huge: __u64,
+pub tp_failed: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_auxdata {
+pub tp_status: __u32,
+pub tp_len: __u32,
+pub tp_snaplen: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub tp_vlan_tci: __u16,
+pub tp_vlan_tpid: __u16,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_hdr {
+pub tp_status: crate::ctypes::c_ulong,
+pub tp_len: crate::ctypes::c_uint,
+pub tp_snaplen: crate::ctypes::c_uint,
+pub tp_mac: crate::ctypes::c_ushort,
+pub tp_net: crate::ctypes::c_ushort,
+pub tp_sec: crate::ctypes::c_uint,
+pub tp_usec: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket2_hdr {
+pub tp_status: __u32,
+pub tp_len: __u32,
+pub tp_snaplen: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub tp_sec: __u32,
+pub tp_nsec: __u32,
+pub tp_vlan_tci: __u16,
+pub tp_vlan_tpid: __u16,
+pub tp_padding: [__u8; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_hdr_variant1 {
+pub tp_rxhash: __u32,
+pub tp_vlan_tci: __u32,
+pub tp_vlan_tpid: __u16,
+pub tp_padding: __u16,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket3_hdr {
+pub tp_next_offset: __u32,
+pub tp_sec: __u32,
+pub tp_nsec: __u32,
+pub tp_snaplen: __u32,
+pub tp_len: __u32,
+pub tp_status: __u32,
+pub tp_mac: __u16,
+pub tp_net: __u16,
+pub __bindgen_anon_1: tpacket3_hdr__bindgen_ty_1,
+pub tp_padding: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket_bd_ts {
+pub ts_sec: crate::ctypes::c_uint,
+pub __bindgen_anon_1: tpacket_bd_ts__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket_hdr_v1 {
+pub block_status: __u32,
+pub num_pkts: __u32,
+pub offset_to_first_pkt: __u32,
+pub blk_len: __u32,
+pub seq_num: __u64,
+pub ts_first_pkt: tpacket_bd_ts,
+pub ts_last_pkt: tpacket_bd_ts,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct tpacket_block_desc {
+pub version: __u32,
+pub offset_to_priv: __u32,
+pub hdr: tpacket_bd_header_u,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_req {
+pub tp_block_size: crate::ctypes::c_uint,
+pub tp_block_nr: crate::ctypes::c_uint,
+pub tp_frame_size: crate::ctypes::c_uint,
+pub tp_frame_nr: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct tpacket_req3 {
+pub tp_block_size: crate::ctypes::c_uint,
+pub tp_block_nr: crate::ctypes::c_uint,
+pub tp_frame_size: crate::ctypes::c_uint,
+pub tp_frame_nr: crate::ctypes::c_uint,
+pub tp_retire_blk_tov: crate::ctypes::c_uint,
+pub tp_sizeof_priv: crate::ctypes::c_uint,
+pub tp_feature_req_word: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct packet_mreq {
+pub mr_ifindex: crate::ctypes::c_int,
+pub mr_type: crate::ctypes::c_ushort,
+pub mr_alen: crate::ctypes::c_ushort,
+pub mr_address: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fanout_args {
+pub id: __u16,
+pub type_flags: __u16,
+pub max_num_members: __u32,
+}
+pub const __LITTLE_ENDIAN: u32 = 1234;
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const PACKET_HOST: u32 = 0;
+pub const PACKET_BROADCAST: u32 = 1;
+pub const PACKET_MULTICAST: u32 = 2;
+pub const PACKET_OTHERHOST: u32 = 3;
+pub const PACKET_OUTGOING: u32 = 4;
+pub const PACKET_LOOPBACK: u32 = 5;
+pub const PACKET_USER: u32 = 6;
+pub const PACKET_KERNEL: u32 = 7;
+pub const PACKET_FASTROUTE: u32 = 6;
+pub const PACKET_ADD_MEMBERSHIP: u32 = 1;
+pub const PACKET_DROP_MEMBERSHIP: u32 = 2;
+pub const PACKET_RECV_OUTPUT: u32 = 3;
+pub const PACKET_RX_RING: u32 = 5;
+pub const PACKET_STATISTICS: u32 = 6;
+pub const PACKET_COPY_THRESH: u32 = 7;
+pub const PACKET_AUXDATA: u32 = 8;
+pub const PACKET_ORIGDEV: u32 = 9;
+pub const PACKET_VERSION: u32 = 10;
+pub const PACKET_HDRLEN: u32 = 11;
+pub const PACKET_RESERVE: u32 = 12;
+pub const PACKET_TX_RING: u32 = 13;
+pub const PACKET_LOSS: u32 = 14;
+pub const PACKET_VNET_HDR: u32 = 15;
+pub const PACKET_TX_TIMESTAMP: u32 = 16;
+pub const PACKET_TIMESTAMP: u32 = 17;
+pub const PACKET_FANOUT: u32 = 18;
+pub const PACKET_TX_HAS_OFF: u32 = 19;
+pub const PACKET_QDISC_BYPASS: u32 = 20;
+pub const PACKET_ROLLOVER_STATS: u32 = 21;
+pub const PACKET_FANOUT_DATA: u32 = 22;
+pub const PACKET_IGNORE_OUTGOING: u32 = 23;
+pub const PACKET_VNET_HDR_SZ: u32 = 24;
+pub const PACKET_FANOUT_HASH: u32 = 0;
+pub const PACKET_FANOUT_LB: u32 = 1;
+pub const PACKET_FANOUT_CPU: u32 = 2;
+pub const PACKET_FANOUT_ROLLOVER: u32 = 3;
+pub const PACKET_FANOUT_RND: u32 = 4;
+pub const PACKET_FANOUT_QM: u32 = 5;
+pub const PACKET_FANOUT_CBPF: u32 = 6;
+pub const PACKET_FANOUT_EBPF: u32 = 7;
+pub const PACKET_FANOUT_FLAG_ROLLOVER: u32 = 4096;
+pub const PACKET_FANOUT_FLAG_UNIQUEID: u32 = 8192;
+pub const PACKET_FANOUT_FLAG_IGNORE_OUTGOING: u32 = 16384;
+pub const PACKET_FANOUT_FLAG_DEFRAG: u32 = 32768;
+pub const TP_STATUS_KERNEL: u32 = 0;
+pub const TP_STATUS_USER: u32 = 1;
+pub const TP_STATUS_COPY: u32 = 2;
+pub const TP_STATUS_LOSING: u32 = 4;
+pub const TP_STATUS_CSUMNOTREADY: u32 = 8;
+pub const TP_STATUS_VLAN_VALID: u32 = 16;
+pub const TP_STATUS_BLK_TMO: u32 = 32;
+pub const TP_STATUS_VLAN_TPID_VALID: u32 = 64;
+pub const TP_STATUS_CSUM_VALID: u32 = 128;
+pub const TP_STATUS_GSO_TCP: u32 = 256;
+pub const TP_STATUS_AVAILABLE: u32 = 0;
+pub const TP_STATUS_SEND_REQUEST: u32 = 1;
+pub const TP_STATUS_SENDING: u32 = 2;
+pub const TP_STATUS_WRONG_FORMAT: u32 = 4;
+pub const TP_STATUS_TS_SOFTWARE: u32 = 536870912;
+pub const TP_STATUS_TS_SYS_HARDWARE: u32 = 1073741824;
+pub const TP_STATUS_TS_RAW_HARDWARE: u32 = 2147483648;
+pub const TP_FT_REQ_FILL_RXHASH: u32 = 1;
+pub const TPACKET_ALIGNMENT: u32 = 16;
+pub const PACKET_MR_MULTICAST: u32 = 0;
+pub const PACKET_MR_PROMISC: u32 = 1;
+pub const PACKET_MR_ALLMULTI: u32 = 2;
+pub const PACKET_MR_UNICAST: u32 = 3;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum tpacket_versions {
+TPACKET_V1 = 0,
+TPACKET_V2 = 1,
+TPACKET_V3 = 2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_stats_u {
+pub stats1: tpacket_stats,
+pub stats3: tpacket_stats_v3,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket3_hdr__bindgen_ty_1 {
+pub hv1: tpacket_hdr_variant1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_bd_ts__bindgen_ty_1 {
+pub ts_usec: crate::ctypes::c_uint,
+pub ts_nsec: crate::ctypes::c_uint,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_bd_header_u {
+pub bh1: tpacket_hdr_v1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union tpacket_req_u {
+pub req: tpacket_req,
+pub req3: tpacket_req3,
+}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/image.rs

@@ -0,0 +1,3 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/io_uring.rs

@@ -0,0 +1,1440 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+pub type __kernel_rwf_t = crate::ctypes::c_int;
+#[repr(C)]
+#[derive(Default)]
+pub struct __IncompleteArrayField<T>(::core::marker::PhantomData<T>, [T; 0]);
+#[repr(C)]
+pub struct __BindgenUnionField<T>(::core::marker::PhantomData<T>);
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v1 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub master_key_descriptor: [__u8; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_key {
+pub mode: __u32,
+pub raw: [__u8; 64usize],
+pub size: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fscrypt_policy_v2 {
+pub version: __u8,
+pub contents_encryption_mode: __u8,
+pub filenames_encryption_mode: __u8,
+pub flags: __u8,
+pub log2_data_unit_size: __u8,
+pub __reserved: [__u8; 3usize],
+pub master_key_identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_policy_ex_arg {
+pub policy_size: __u64,
+pub policy: fscrypt_get_policy_ex_arg__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_key_specifier {
+pub type_: __u32,
+pub __reserved: __u32,
+pub u: fscrypt_key_specifier__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct fscrypt_provisioning_key_payload {
+pub type_: __u32,
+pub flags: __u32,
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+pub struct fscrypt_add_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub raw_size: __u32,
+pub key_id: __u32,
+pub flags: __u32,
+pub __reserved: [__u32; 7usize],
+pub raw: __IncompleteArrayField<__u8>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_remove_key_arg {
+pub key_spec: fscrypt_key_specifier,
+pub removal_status_flags: __u32,
+pub __reserved: [__u32; 5usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct fscrypt_get_key_status_arg {
+pub key_spec: fscrypt_key_specifier,
+pub __reserved: [__u32; 6usize],
+pub status: __u32,
+pub status_flags: __u32,
+pub user_count: __u32,
+pub __out_reserved: [__u32; 13usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mount_attr {
+pub attr_set: __u64,
+pub attr_clr: __u64,
+pub propagation: __u64,
+pub userns_fd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct statmount {
+pub size: __u32,
+pub mnt_opts: __u32,
+pub mask: __u64,
+pub sb_dev_major: __u32,
+pub sb_dev_minor: __u32,
+pub sb_magic: __u64,
+pub sb_flags: __u32,
+pub fs_type: __u32,
+pub mnt_id: __u64,
+pub mnt_parent_id: __u64,
+pub mnt_id_old: __u32,
+pub mnt_parent_id_old: __u32,
+pub mnt_attr: __u64,
+pub mnt_propagation: __u64,
+pub mnt_peer_group: __u64,
+pub mnt_master: __u64,
+pub propagate_from: __u64,
+pub mnt_root: __u32,
+pub mnt_point: __u32,
+pub mnt_ns_id: __u64,
+pub fs_subtype: __u32,
+pub sb_source: __u32,
+pub opt_num: __u32,
+pub opt_array: __u32,
+pub opt_sec_num: __u32,
+pub opt_sec_array: __u32,
+pub supported_mask: __u64,
+pub mnt_uidmap_num: __u32,
+pub mnt_uidmap: __u32,
+pub mnt_gidmap_num: __u32,
+pub mnt_gidmap: __u32,
+pub __spare2: [__u64; 43usize],
+pub str_: __IncompleteArrayField<crate::ctypes::c_char>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct mnt_id_req {
+pub size: __u32,
+pub spare: __u32,
+pub mnt_id: __u64,
+pub param: __u64,
+pub mnt_ns_id: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_clone_range {
+pub src_fd: __s64,
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_offset: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fstrim_range {
+pub start: __u64,
+pub len: __u64,
+pub minlen: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsuuid2 {
+pub len: __u8,
+pub uuid: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fs_sysfs_path {
+pub len: __u8,
+pub name: [__u8; 128usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct file_dedupe_range_info {
+pub dest_fd: __s64,
+pub dest_offset: __u64,
+pub bytes_deduped: __u64,
+pub status: __s32,
+pub reserved: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct file_dedupe_range {
+pub src_offset: __u64,
+pub src_length: __u64,
+pub dest_count: __u16,
+pub reserved1: __u16,
+pub reserved2: __u32,
+pub info: __IncompleteArrayField<file_dedupe_range_info>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct files_stat_struct {
+pub nr_files: crate::ctypes::c_ulong,
+pub nr_free_files: crate::ctypes::c_ulong,
+pub max_files: crate::ctypes::c_ulong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct inodes_stat_t {
+pub nr_inodes: crate::ctypes::c_long,
+pub nr_unused: crate::ctypes::c_long,
+pub dummy: [crate::ctypes::c_long; 5usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct fsxattr {
+pub fsx_xflags: __u32,
+pub fsx_extsize: __u32,
+pub fsx_nextents: __u32,
+pub fsx_projid: __u32,
+pub fsx_cowextsize: __u32,
+pub fsx_pad: [crate::ctypes::c_uchar; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct page_region {
+pub start: __u64,
+pub end: __u64,
+pub categories: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct pm_scan_arg {
+pub size: __u64,
+pub flags: __u64,
+pub start: __u64,
+pub end: __u64,
+pub walk_end: __u64,
+pub vec: __u64,
+pub vec_len: __u64,
+pub max_pages: __u64,
+pub category_inverted: __u64,
+pub category_mask: __u64,
+pub category_anyof_mask: __u64,
+pub return_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct procmap_query {
+pub size: __u64,
+pub query_flags: __u64,
+pub query_addr: __u64,
+pub vma_start: __u64,
+pub vma_end: __u64,
+pub vma_flags: __u64,
+pub vma_page_size: __u64,
+pub vma_offset: __u64,
+pub inode: __u64,
+pub dev_major: __u32,
+pub dev_minor: __u32,
+pub vma_name_size: __u32,
+pub build_id_size: __u32,
+pub vma_name_addr: __u64,
+pub build_id_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_timespec {
+pub tv_sec: __kernel_time64_t,
+pub tv_nsec: crate::ctypes::c_longlong,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_itimerspec {
+pub it_interval: __kernel_timespec,
+pub it_value: __kernel_timespec,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_timeval {
+pub tv_sec: __kernel_long_t,
+pub tv_usec: __kernel_long_t,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_timespec {
+pub tv_sec: __kernel_old_time_t,
+pub tv_nsec: crate::ctypes::c_long,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_old_itimerval {
+pub it_interval: __kernel_old_timeval,
+pub it_value: __kernel_old_timeval,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct __kernel_sock_timeval {
+pub tv_sec: __s64,
+pub tv_usec: __s64,
+}
+#[repr(C)]
+pub struct io_uring_sqe {
+pub opcode: __u8,
+pub flags: __u8,
+pub ioprio: __u16,
+pub fd: __s32,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1,
+pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_2,
+pub len: __u32,
+pub __bindgen_anon_3: io_uring_sqe__bindgen_ty_3,
+pub user_data: __u64,
+pub __bindgen_anon_4: io_uring_sqe__bindgen_ty_4,
+pub personality: __u16,
+pub __bindgen_anon_5: io_uring_sqe__bindgen_ty_5,
+pub __bindgen_anon_6: io_uring_sqe__bindgen_ty_6,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_1__bindgen_ty_1 {
+pub cmd_op: __u32,
+pub __pad1: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_2__bindgen_ty_1 {
+pub level: __u32,
+pub optname: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_1 {
+pub addr_len: __u16,
+pub __pad3: [__u16; 1usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_5__bindgen_ty_2 {
+pub write_stream: __u8,
+pub __pad4: [__u8; 3usize],
+}
+#[repr(C)]
+pub struct io_uring_sqe__bindgen_ty_6 {
+pub __bindgen_anon_1: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_1>,
+pub __bindgen_anon_2: __BindgenUnionField<io_uring_sqe__bindgen_ty_6__bindgen_ty_2>,
+pub optval: __BindgenUnionField<__u64>,
+pub cmd: __BindgenUnionField<[__u8; 0usize]>,
+pub bindgen_union_field: [u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_1 {
+pub addr3: __u64,
+pub __pad2: [__u64; 1usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sqe__bindgen_ty_6__bindgen_ty_2 {
+pub attr_ptr: __u64,
+pub attr_type_mask: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_attr_pi {
+pub flags: __u16,
+pub app_tag: __u16,
+pub len: __u32,
+pub addr: __u64,
+pub seed: __u64,
+pub rsvd: __u64,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_cqe {
+pub user_data: __u64,
+pub res: __s32,
+pub flags: __u32,
+pub big_cqe: __IncompleteArrayField<__u64>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_sqring_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub ring_mask: __u32,
+pub ring_entries: __u32,
+pub flags: __u32,
+pub dropped: __u32,
+pub array: __u32,
+pub resv1: __u32,
+pub user_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_cqring_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub ring_mask: __u32,
+pub ring_entries: __u32,
+pub overflow: __u32,
+pub cqes: __u32,
+pub flags: __u32,
+pub resv1: __u32,
+pub user_addr: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_params {
+pub sq_entries: __u32,
+pub cq_entries: __u32,
+pub flags: __u32,
+pub sq_thread_cpu: __u32,
+pub sq_thread_idle: __u32,
+pub features: __u32,
+pub wq_fd: __u32,
+pub resv: [__u32; 3usize],
+pub sq_off: io_sqring_offsets,
+pub cq_off: io_cqring_offsets,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_files_update {
+pub offset: __u32,
+pub resv: __u32,
+pub fds: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_region_desc {
+pub user_addr: __u64,
+pub size: __u64,
+pub flags: __u32,
+pub id: __u32,
+pub mmap_offset: __u64,
+pub __resv: [__u64; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_mem_region_reg {
+pub region_uptr: __u64,
+pub flags: __u64,
+pub __resv: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_register {
+pub nr: __u32,
+pub flags: __u32,
+pub resv2: __u64,
+pub data: __u64,
+pub tags: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_update {
+pub offset: __u32,
+pub resv: __u32,
+pub data: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_rsrc_update2 {
+pub offset: __u32,
+pub resv: __u32,
+pub data: __u64,
+pub tags: __u64,
+pub nr: __u32,
+pub resv2: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_probe_op {
+pub op: __u8,
+pub resv: __u8,
+pub flags: __u16,
+pub resv2: __u32,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_probe {
+pub last_op: __u8,
+pub ops_len: __u8,
+pub resv: __u16,
+pub resv2: [__u32; 3usize],
+pub ops: __IncompleteArrayField<io_uring_probe_op>,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct io_uring_restriction {
+pub opcode: __u16,
+pub __bindgen_anon_1: io_uring_restriction__bindgen_ty_1,
+pub resv: __u8,
+pub resv2: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_clock_register {
+pub clockid: __u32,
+pub __resv: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_clone_buffers {
+pub src_fd: __u32,
+pub flags: __u32,
+pub src_off: __u32,
+pub dst_off: __u32,
+pub nr: __u32,
+pub pad: [__u32; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf {
+pub addr: __u64,
+pub len: __u32,
+pub bid: __u16,
+pub resv: __u16,
+}
+#[repr(C)]
+pub struct io_uring_buf_ring {
+pub __bindgen_anon_1: io_uring_buf_ring__bindgen_ty_1,
+}
+#[repr(C)]
+pub struct io_uring_buf_ring__bindgen_ty_1 {
+pub __bindgen_anon_1: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1>,
+pub __bindgen_anon_2: __BindgenUnionField<io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2>,
+pub bindgen_union_field: [u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_1 {
+pub resv1: __u64,
+pub resv2: __u32,
+pub resv3: __u16,
+pub tail: __u16,
+}
+#[repr(C)]
+#[derive(Debug)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2 {
+pub __empty_bufs: io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1,
+pub bufs: __IncompleteArrayField<io_uring_buf>,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_ring__bindgen_ty_1__bindgen_ty_2__bindgen_ty_1 {}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_reg {
+pub ring_addr: __u64,
+pub ring_entries: __u32,
+pub bgid: __u16,
+pub flags: __u16,
+pub resv: [__u64; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_buf_status {
+pub buf_group: __u32,
+pub head: __u32,
+pub resv: [__u32; 8usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_napi {
+pub busy_poll_to: __u32,
+pub prefer_busy_poll: __u8,
+pub opcode: __u8,
+pub pad: [__u8; 2usize],
+pub op_param: __u32,
+pub resv: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_reg_wait {
+pub ts: __kernel_timespec,
+pub min_wait_usec: __u32,
+pub flags: __u32,
+pub sigmask: __u64,
+pub sigmask_sz: __u32,
+pub pad: [__u32; 3usize],
+pub pad2: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_getevents_arg {
+pub sigmask: __u64,
+pub sigmask_sz: __u32,
+pub min_wait_usec: __u32,
+pub ts: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_sync_cancel_reg {
+pub addr: __u64,
+pub fd: __s32,
+pub flags: __u32,
+pub timeout: __kernel_timespec,
+pub opcode: __u8,
+pub pad: [__u8; 7usize],
+pub pad2: [__u64; 3usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_file_index_range {
+pub off: __u32,
+pub len: __u32,
+pub resv: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_recvmsg_out {
+pub namelen: __u32,
+pub controllen: __u32,
+pub payloadlen: __u32,
+pub flags: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_rqe {
+pub off: __u64,
+pub len: __u32,
+pub __pad: __u32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_cqe {
+pub off: __u64,
+pub __pad: __u64,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_offsets {
+pub head: __u32,
+pub tail: __u32,
+pub rqes: __u32,
+pub __resv2: __u32,
+pub __resv: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_area_reg {
+pub addr: __u64,
+pub len: __u64,
+pub rq_area_token: __u64,
+pub flags: __u32,
+pub dmabuf_fd: __u32,
+pub __resv2: [__u64; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct io_uring_zcrx_ifq_reg {
+pub if_idx: __u32,
+pub if_rxq: __u32,
+pub rq_entries: __u32,
+pub flags: __u32,
+pub area_ptr: __u64,
+pub region_ptr: __u64,
+pub offsets: io_uring_zcrx_offsets,
+pub zcrx_id: __u32,
+pub __resv2: __u32,
+pub __resv: [__u64; 3usize],
+}
+pub const NR_OPEN: u32 = 1024;
+pub const NGROUPS_MAX: u32 = 65536;
+pub const ARG_MAX: u32 = 131072;
+pub const LINK_MAX: u32 = 127;
+pub const MAX_CANON: u32 = 255;
+pub const MAX_INPUT: u32 = 255;
+pub const NAME_MAX: u32 = 255;
+pub const PATH_MAX: u32 = 4096;
+pub const PIPE_BUF: u32 = 4096;
+pub const XATTR_NAME_MAX: u32 = 255;
+pub const XATTR_SIZE_MAX: u32 = 65536;
+pub const XATTR_LIST_MAX: u32 = 65536;
+pub const RTSIG_MAX: u32 = 32;
+pub const _IOC_NRBITS: u32 = 8;
+pub const _IOC_TYPEBITS: u32 = 8;
+pub const _IOC_SIZEBITS: u32 = 14;
+pub const _IOC_DIRBITS: u32 = 2;
+pub const _IOC_NRMASK: u32 = 255;
+pub const _IOC_TYPEMASK: u32 = 255;
+pub const _IOC_SIZEMASK: u32 = 16383;
+pub const _IOC_DIRMASK: u32 = 3;
+pub const _IOC_NRSHIFT: u32 = 0;
+pub const _IOC_TYPESHIFT: u32 = 8;
+pub const _IOC_SIZESHIFT: u32 = 16;
+pub const _IOC_DIRSHIFT: u32 = 30;
+pub const _IOC_NONE: u32 = 0;
+pub const _IOC_WRITE: u32 = 1;
+pub const _IOC_READ: u32 = 2;
+pub const IOC_IN: u32 = 1073741824;
+pub const IOC_OUT: u32 = 2147483648;
+pub const IOC_INOUT: u32 = 3221225472;
+pub const IOCSIZE_MASK: u32 = 1073676288;
+pub const IOCSIZE_SHIFT: u32 = 16;
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const FSCRYPT_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FSCRYPT_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FSCRYPT_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FSCRYPT_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FSCRYPT_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FSCRYPT_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_64: u32 = 8;
+pub const FSCRYPT_POLICY_FLAG_IV_INO_LBLK_32: u32 = 16;
+pub const FSCRYPT_MODE_AES_256_XTS: u32 = 1;
+pub const FSCRYPT_MODE_AES_256_CTS: u32 = 4;
+pub const FSCRYPT_MODE_AES_128_CBC: u32 = 5;
+pub const FSCRYPT_MODE_AES_128_CTS: u32 = 6;
+pub const FSCRYPT_MODE_SM4_XTS: u32 = 7;
+pub const FSCRYPT_MODE_SM4_CTS: u32 = 8;
+pub const FSCRYPT_MODE_ADIANTUM: u32 = 9;
+pub const FSCRYPT_MODE_AES_256_HCTR2: u32 = 10;
+pub const FSCRYPT_POLICY_V1: u32 = 0;
+pub const FSCRYPT_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FSCRYPT_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FSCRYPT_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FSCRYPT_MAX_KEY_SIZE: u32 = 64;
+pub const FSCRYPT_POLICY_V2: u32 = 2;
+pub const FSCRYPT_KEY_IDENTIFIER_SIZE: u32 = 16;
+pub const FSCRYPT_KEY_SPEC_TYPE_DESCRIPTOR: u32 = 1;
+pub const FSCRYPT_KEY_SPEC_TYPE_IDENTIFIER: u32 = 2;
+pub const FSCRYPT_ADD_KEY_FLAG_HW_WRAPPED: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_FILES_BUSY: u32 = 1;
+pub const FSCRYPT_KEY_REMOVAL_STATUS_FLAG_OTHER_USERS: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_ABSENT: u32 = 1;
+pub const FSCRYPT_KEY_STATUS_PRESENT: u32 = 2;
+pub const FSCRYPT_KEY_STATUS_INCOMPLETELY_REMOVED: u32 = 3;
+pub const FSCRYPT_KEY_STATUS_FLAG_ADDED_BY_SELF: u32 = 1;
+pub const FS_KEY_DESCRIPTOR_SIZE: u32 = 8;
+pub const FS_POLICY_FLAGS_PAD_4: u32 = 0;
+pub const FS_POLICY_FLAGS_PAD_8: u32 = 1;
+pub const FS_POLICY_FLAGS_PAD_16: u32 = 2;
+pub const FS_POLICY_FLAGS_PAD_32: u32 = 3;
+pub const FS_POLICY_FLAGS_PAD_MASK: u32 = 3;
+pub const FS_POLICY_FLAG_DIRECT_KEY: u32 = 4;
+pub const FS_POLICY_FLAGS_VALID: u32 = 7;
+pub const FS_ENCRYPTION_MODE_INVALID: u32 = 0;
+pub const FS_ENCRYPTION_MODE_AES_256_XTS: u32 = 1;
+pub const FS_ENCRYPTION_MODE_AES_256_GCM: u32 = 2;
+pub const FS_ENCRYPTION_MODE_AES_256_CBC: u32 = 3;
+pub const FS_ENCRYPTION_MODE_AES_256_CTS: u32 = 4;
+pub const FS_ENCRYPTION_MODE_AES_128_CBC: u32 = 5;
+pub const FS_ENCRYPTION_MODE_AES_128_CTS: u32 = 6;
+pub const FS_ENCRYPTION_MODE_ADIANTUM: u32 = 9;
+pub const FS_KEY_DESC_PREFIX: &[u8; 9] = b"fscrypt:\0";
+pub const FS_KEY_DESC_PREFIX_SIZE: u32 = 8;
+pub const FS_MAX_KEY_SIZE: u32 = 64;
+pub const MS_RDONLY: u32 = 1;
+pub const MS_NOSUID: u32 = 2;
+pub const MS_NODEV: u32 = 4;
+pub const MS_NOEXEC: u32 = 8;
+pub const MS_SYNCHRONOUS: u32 = 16;
+pub const MS_REMOUNT: u32 = 32;
+pub const MS_MANDLOCK: u32 = 64;
+pub const MS_DIRSYNC: u32 = 128;
+pub const MS_NOSYMFOLLOW: u32 = 256;
+pub const MS_NOATIME: u32 = 1024;
+pub const MS_NODIRATIME: u32 = 2048;
+pub const MS_BIND: u32 = 4096;
+pub const MS_MOVE: u32 = 8192;
+pub const MS_REC: u32 = 16384;
+pub const MS_VERBOSE: u32 = 32768;
+pub const MS_SILENT: u32 = 32768;
+pub const MS_POSIXACL: u32 = 65536;
+pub const MS_UNBINDABLE: u32 = 131072;
+pub const MS_PRIVATE: u32 = 262144;
+pub const MS_SLAVE: u32 = 524288;
+pub const MS_SHARED: u32 = 1048576;
+pub const MS_RELATIME: u32 = 2097152;
+pub const MS_KERNMOUNT: u32 = 4194304;
+pub const MS_I_VERSION: u32 = 8388608;
+pub const MS_STRICTATIME: u32 = 16777216;
+pub const MS_LAZYTIME: u32 = 33554432;
+pub const MS_SUBMOUNT: u32 = 67108864;
+pub const MS_NOREMOTELOCK: u32 = 134217728;
+pub const MS_NOSEC: u32 = 268435456;
+pub const MS_BORN: u32 = 536870912;
+pub const MS_ACTIVE: u32 = 1073741824;
+pub const MS_NOUSER: u32 = 2147483648;
+pub const MS_RMT_MASK: u32 = 41943121;
+pub const MS_MGC_VAL: u32 = 3236757504;
+pub const MS_MGC_MSK: u32 = 4294901760;
+pub const OPEN_TREE_CLONE: u32 = 1;
+pub const MOVE_MOUNT_F_SYMLINKS: u32 = 1;
+pub const MOVE_MOUNT_F_AUTOMOUNTS: u32 = 2;
+pub const MOVE_MOUNT_F_EMPTY_PATH: u32 = 4;
+pub const MOVE_MOUNT_T_SYMLINKS: u32 = 16;
+pub const MOVE_MOUNT_T_AUTOMOUNTS: u32 = 32;
+pub const MOVE_MOUNT_T_EMPTY_PATH: u32 = 64;
+pub const MOVE_MOUNT_SET_GROUP: u32 = 256;
+pub const MOVE_MOUNT_BENEATH: u32 = 512;
+pub const MOVE_MOUNT__MASK: u32 = 887;
+pub const FSOPEN_CLOEXEC: u32 = 1;
+pub const FSPICK_CLOEXEC: u32 = 1;
+pub const FSPICK_SYMLINK_NOFOLLOW: u32 = 2;
+pub const FSPICK_NO_AUTOMOUNT: u32 = 4;
+pub const FSPICK_EMPTY_PATH: u32 = 8;
+pub const FSMOUNT_CLOEXEC: u32 = 1;
+pub const MOUNT_ATTR_RDONLY: u32 = 1;
+pub const MOUNT_ATTR_NOSUID: u32 = 2;
+pub const MOUNT_ATTR_NODEV: u32 = 4;
+pub const MOUNT_ATTR_NOEXEC: u32 = 8;
+pub const MOUNT_ATTR__ATIME: u32 = 112;
+pub const MOUNT_ATTR_RELATIME: u32 = 0;
+pub const MOUNT_ATTR_NOATIME: u32 = 16;
+pub const MOUNT_ATTR_STRICTATIME: u32 = 32;
+pub const MOUNT_ATTR_NODIRATIME: u32 = 128;
+pub const MOUNT_ATTR_IDMAP: u32 = 1048576;
+pub const MOUNT_ATTR_NOSYMFOLLOW: u32 = 2097152;
+pub const MOUNT_ATTR_SIZE_VER0: u32 = 32;
+pub const MNT_ID_REQ_SIZE_VER0: u32 = 24;
+pub const MNT_ID_REQ_SIZE_VER1: u32 = 32;
+pub const STATMOUNT_SB_BASIC: u32 = 1;
+pub const STATMOUNT_MNT_BASIC: u32 = 2;
+pub const STATMOUNT_PROPAGATE_FROM: u32 = 4;
+pub const STATMOUNT_MNT_ROOT: u32 = 8;
+pub const STATMOUNT_MNT_POINT: u32 = 16;
+pub const STATMOUNT_FS_TYPE: u32 = 32;
+pub const STATMOUNT_MNT_NS_ID: u32 = 64;
+pub const STATMOUNT_MNT_OPTS: u32 = 128;
+pub const STATMOUNT_FS_SUBTYPE: u32 = 256;
+pub const STATMOUNT_SB_SOURCE: u32 = 512;
+pub const STATMOUNT_OPT_ARRAY: u32 = 1024;
+pub const STATMOUNT_OPT_SEC_ARRAY: u32 = 2048;
+pub const STATMOUNT_SUPPORTED_MASK: u32 = 4096;
+pub const STATMOUNT_MNT_UIDMAP: u32 = 8192;
+pub const STATMOUNT_MNT_GIDMAP: u32 = 16384;
+pub const LSMT_ROOT: i32 = -1;
+pub const LISTMOUNT_REVERSE: u32 = 1;
+pub const INR_OPEN_CUR: u32 = 1024;
+pub const INR_OPEN_MAX: u32 = 4096;
+pub const BLOCK_SIZE_BITS: u32 = 10;
+pub const BLOCK_SIZE: u32 = 1024;
+pub const IO_INTEGRITY_CHK_GUARD: u32 = 1;
+pub const IO_INTEGRITY_CHK_REFTAG: u32 = 2;
+pub const IO_INTEGRITY_CHK_APPTAG: u32 = 4;
+pub const IO_INTEGRITY_VALID_FLAGS: u32 = 7;
+pub const SEEK_SET: u32 = 0;
+pub const SEEK_CUR: u32 = 1;
+pub const SEEK_END: u32 = 2;
+pub const SEEK_DATA: u32 = 3;
+pub const SEEK_HOLE: u32 = 4;
+pub const SEEK_MAX: u32 = 4;
+pub const RENAME_NOREPLACE: u32 = 1;
+pub const RENAME_EXCHANGE: u32 = 2;
+pub const RENAME_WHITEOUT: u32 = 4;
+pub const FILE_DEDUPE_RANGE_SAME: u32 = 0;
+pub const FILE_DEDUPE_RANGE_DIFFERS: u32 = 1;
+pub const NR_FILE: u32 = 8192;
+pub const FS_XFLAG_REALTIME: u32 = 1;
+pub const FS_XFLAG_PREALLOC: u32 = 2;
+pub const FS_XFLAG_IMMUTABLE: u32 = 8;
+pub const FS_XFLAG_APPEND: u32 = 16;
+pub const FS_XFLAG_SYNC: u32 = 32;
+pub const FS_XFLAG_NOATIME: u32 = 64;
+pub const FS_XFLAG_NODUMP: u32 = 128;
+pub const FS_XFLAG_RTINHERIT: u32 = 256;
+pub const FS_XFLAG_PROJINHERIT: u32 = 512;
+pub const FS_XFLAG_NOSYMLINKS: u32 = 1024;
+pub const FS_XFLAG_EXTSIZE: u32 = 2048;
+pub const FS_XFLAG_EXTSZINHERIT: u32 = 4096;
+pub const FS_XFLAG_NODEFRAG: u32 = 8192;
+pub const FS_XFLAG_FILESTREAM: u32 = 16384;
+pub const FS_XFLAG_DAX: u32 = 32768;
+pub const FS_XFLAG_COWEXTSIZE: u32 = 65536;
+pub const FS_XFLAG_HASATTR: u32 = 2147483648;
+pub const BMAP_IOCTL: u32 = 1;
+pub const FSLABEL_MAX: u32 = 256;
+pub const FS_SECRM_FL: u32 = 1;
+pub const FS_UNRM_FL: u32 = 2;
+pub const FS_COMPR_FL: u32 = 4;
+pub const FS_SYNC_FL: u32 = 8;
+pub const FS_IMMUTABLE_FL: u32 = 16;
+pub const FS_APPEND_FL: u32 = 32;
+pub const FS_NODUMP_FL: u32 = 64;
+pub const FS_NOATIME_FL: u32 = 128;
+pub const FS_DIRTY_FL: u32 = 256;
+pub const FS_COMPRBLK_FL: u32 = 512;
+pub const FS_NOCOMP_FL: u32 = 1024;
+pub const FS_ENCRYPT_FL: u32 = 2048;
+pub const FS_BTREE_FL: u32 = 4096;
+pub const FS_INDEX_FL: u32 = 4096;
+pub const FS_IMAGIC_FL: u32 = 8192;
+pub const FS_JOURNAL_DATA_FL: u32 = 16384;
+pub const FS_NOTAIL_FL: u32 = 32768;
+pub const FS_DIRSYNC_FL: u32 = 65536;
+pub const FS_TOPDIR_FL: u32 = 131072;
+pub const FS_HUGE_FILE_FL: u32 = 262144;
+pub const FS_EXTENT_FL: u32 = 524288;
+pub const FS_VERITY_FL: u32 = 1048576;
+pub const FS_EA_INODE_FL: u32 = 2097152;
+pub const FS_EOFBLOCKS_FL: u32 = 4194304;
+pub const FS_NOCOW_FL: u32 = 8388608;
+pub const FS_DAX_FL: u32 = 33554432;
+pub const FS_INLINE_DATA_FL: u32 = 268435456;
+pub const FS_PROJINHERIT_FL: u32 = 536870912;
+pub const FS_CASEFOLD_FL: u32 = 1073741824;
+pub const FS_RESERVED_FL: u32 = 2147483648;
+pub const FS_FL_USER_VISIBLE: u32 = 253951;
+pub const FS_FL_USER_MODIFIABLE: u32 = 229631;
+pub const SYNC_FILE_RANGE_WAIT_BEFORE: u32 = 1;
+pub const SYNC_FILE_RANGE_WRITE: u32 = 2;
+pub const SYNC_FILE_RANGE_WAIT_AFTER: u32 = 4;
+pub const SYNC_FILE_RANGE_WRITE_AND_WAIT: u32 = 7;
+pub const PROCFS_IOCTL_MAGIC: u8 = 102u8;
+pub const PAGE_IS_WPALLOWED: u32 = 1;
+pub const PAGE_IS_WRITTEN: u32 = 2;
+pub const PAGE_IS_FILE: u32 = 4;
+pub const PAGE_IS_PRESENT: u32 = 8;
+pub const PAGE_IS_SWAPPED: u32 = 16;
+pub const PAGE_IS_PFNZERO: u32 = 32;
+pub const PAGE_IS_HUGE: u32 = 64;
+pub const PAGE_IS_SOFT_DIRTY: u32 = 128;
+pub const PAGE_IS_GUARD: u32 = 256;
+pub const PM_SCAN_WP_MATCHING: u32 = 1;
+pub const PM_SCAN_CHECK_WPASYNC: u32 = 2;
+pub const IORING_RW_ATTR_FLAG_PI: u32 = 1;
+pub const IORING_FILE_INDEX_ALLOC: i32 = -1;
+pub const IORING_SETUP_IOPOLL: u32 = 1;
+pub const IORING_SETUP_SQPOLL: u32 = 2;
+pub const IORING_SETUP_SQ_AFF: u32 = 4;
+pub const IORING_SETUP_CQSIZE: u32 = 8;
+pub const IORING_SETUP_CLAMP: u32 = 16;
+pub const IORING_SETUP_ATTACH_WQ: u32 = 32;
+pub const IORING_SETUP_R_DISABLED: u32 = 64;
+pub const IORING_SETUP_SUBMIT_ALL: u32 = 128;
+pub const IORING_SETUP_COOP_TASKRUN: u32 = 256;
+pub const IORING_SETUP_TASKRUN_FLAG: u32 = 512;
+pub const IORING_SETUP_SQE128: u32 = 1024;
+pub const IORING_SETUP_CQE32: u32 = 2048;
+pub const IORING_SETUP_SINGLE_ISSUER: u32 = 4096;
+pub const IORING_SETUP_DEFER_TASKRUN: u32 = 8192;
+pub const IORING_SETUP_NO_MMAP: u32 = 16384;
+pub const IORING_SETUP_REGISTERED_FD_ONLY: u32 = 32768;
+pub const IORING_SETUP_NO_SQARRAY: u32 = 65536;
+pub const IORING_SETUP_HYBRID_IOPOLL: u32 = 131072;
+pub const IORING_URING_CMD_FIXED: u32 = 1;
+pub const IORING_URING_CMD_MASK: u32 = 1;
+pub const IORING_FSYNC_DATASYNC: u32 = 1;
+pub const IORING_TIMEOUT_ABS: u32 = 1;
+pub const IORING_TIMEOUT_UPDATE: u32 = 2;
+pub const IORING_TIMEOUT_BOOTTIME: u32 = 4;
+pub const IORING_TIMEOUT_REALTIME: u32 = 8;
+pub const IORING_LINK_TIMEOUT_UPDATE: u32 = 16;
+pub const IORING_TIMEOUT_ETIME_SUCCESS: u32 = 32;
+pub const IORING_TIMEOUT_MULTISHOT: u32 = 64;
+pub const IORING_TIMEOUT_CLOCK_MASK: u32 = 12;
+pub const IORING_TIMEOUT_UPDATE_MASK: u32 = 18;
+pub const SPLICE_F_FD_IN_FIXED: u32 = 2147483648;
+pub const IORING_POLL_ADD_MULTI: u32 = 1;
+pub const IORING_POLL_UPDATE_EVENTS: u32 = 2;
+pub const IORING_POLL_UPDATE_USER_DATA: u32 = 4;
+pub const IORING_POLL_ADD_LEVEL: u32 = 8;
+pub const IORING_ASYNC_CANCEL_ALL: u32 = 1;
+pub const IORING_ASYNC_CANCEL_FD: u32 = 2;
+pub const IORING_ASYNC_CANCEL_ANY: u32 = 4;
+pub const IORING_ASYNC_CANCEL_FD_FIXED: u32 = 8;
+pub const IORING_ASYNC_CANCEL_USERDATA: u32 = 16;
+pub const IORING_ASYNC_CANCEL_OP: u32 = 32;
+pub const IORING_RECVSEND_POLL_FIRST: u32 = 1;
+pub const IORING_RECV_MULTISHOT: u32 = 2;
+pub const IORING_RECVSEND_FIXED_BUF: u32 = 4;
+pub const IORING_SEND_ZC_REPORT_USAGE: u32 = 8;
+pub const IORING_RECVSEND_BUNDLE: u32 = 16;
+pub const IORING_NOTIF_USAGE_ZC_COPIED: u32 = 2147483648;
+pub const IORING_ACCEPT_MULTISHOT: u32 = 1;
+pub const IORING_ACCEPT_DONTWAIT: u32 = 2;
+pub const IORING_ACCEPT_POLL_FIRST: u32 = 4;
+pub const IORING_MSG_RING_CQE_SKIP: u32 = 1;
+pub const IORING_MSG_RING_FLAGS_PASS: u32 = 2;
+pub const IORING_FIXED_FD_NO_CLOEXEC: u32 = 1;
+pub const IORING_NOP_INJECT_RESULT: u32 = 1;
+pub const IORING_NOP_FILE: u32 = 2;
+pub const IORING_NOP_FIXED_FILE: u32 = 4;
+pub const IORING_NOP_FIXED_BUFFER: u32 = 8;
+pub const IORING_CQE_F_BUFFER: u32 = 1;
+pub const IORING_CQE_F_MORE: u32 = 2;
+pub const IORING_CQE_F_SOCK_NONEMPTY: u32 = 4;
+pub const IORING_CQE_F_NOTIF: u32 = 8;
+pub const IORING_CQE_F_BUF_MORE: u32 = 16;
+pub const IORING_CQE_BUFFER_SHIFT: u32 = 16;
+pub const IORING_OFF_SQ_RING: u32 = 0;
+pub const IORING_OFF_CQ_RING: u32 = 134217728;
+pub const IORING_OFF_SQES: u32 = 268435456;
+pub const IORING_OFF_PBUF_RING: u32 = 2147483648;
+pub const IORING_OFF_PBUF_SHIFT: u32 = 16;
+pub const IORING_OFF_MMAP_MASK: u32 = 4160749568;
+pub const IORING_SQ_NEED_WAKEUP: u32 = 1;
+pub const IORING_SQ_CQ_OVERFLOW: u32 = 2;
+pub const IORING_SQ_TASKRUN: u32 = 4;
+pub const IORING_CQ_EVENTFD_DISABLED: u32 = 1;
+pub const IORING_ENTER_GETEVENTS: u32 = 1;
+pub const IORING_ENTER_SQ_WAKEUP: u32 = 2;
+pub const IORING_ENTER_SQ_WAIT: u32 = 4;
+pub const IORING_ENTER_EXT_ARG: u32 = 8;
+pub const IORING_ENTER_REGISTERED_RING: u32 = 16;
+pub const IORING_ENTER_ABS_TIMER: u32 = 32;
+pub const IORING_ENTER_EXT_ARG_REG: u32 = 64;
+pub const IORING_ENTER_NO_IOWAIT: u32 = 128;
+pub const IORING_FEAT_SINGLE_MMAP: u32 = 1;
+pub const IORING_FEAT_NODROP: u32 = 2;
+pub const IORING_FEAT_SUBMIT_STABLE: u32 = 4;
+pub const IORING_FEAT_RW_CUR_POS: u32 = 8;
+pub const IORING_FEAT_CUR_PERSONALITY: u32 = 16;
+pub const IORING_FEAT_FAST_POLL: u32 = 32;
+pub const IORING_FEAT_POLL_32BITS: u32 = 64;
+pub const IORING_FEAT_SQPOLL_NONFIXED: u32 = 128;
+pub const IORING_FEAT_EXT_ARG: u32 = 256;
+pub const IORING_FEAT_NATIVE_WORKERS: u32 = 512;
+pub const IORING_FEAT_RSRC_TAGS: u32 = 1024;
+pub const IORING_FEAT_CQE_SKIP: u32 = 2048;
+pub const IORING_FEAT_LINKED_FILE: u32 = 4096;
+pub const IORING_FEAT_REG_REG_RING: u32 = 8192;
+pub const IORING_FEAT_RECVSEND_BUNDLE: u32 = 16384;
+pub const IORING_FEAT_MIN_TIMEOUT: u32 = 32768;
+pub const IORING_FEAT_RW_ATTR: u32 = 65536;
+pub const IORING_FEAT_NO_IOWAIT: u32 = 131072;
+pub const IORING_RSRC_REGISTER_SPARSE: u32 = 1;
+pub const IORING_REGISTER_FILES_SKIP: i32 = -2;
+pub const IO_URING_OP_SUPPORTED: u32 = 1;
+pub const IORING_ZCRX_AREA_SHIFT: u32 = 48;
+pub const IORING_MEM_REGION_TYPE_USER: _bindgen_ty_1 = _bindgen_ty_1::IORING_MEM_REGION_TYPE_USER;
+pub const IORING_MEM_REGION_REG_WAIT_ARG: _bindgen_ty_2 = _bindgen_ty_2::IORING_MEM_REGION_REG_WAIT_ARG;
+pub const IORING_REGISTER_SRC_REGISTERED: _bindgen_ty_3 = _bindgen_ty_3::IORING_REGISTER_SRC_REGISTERED;
+pub const IORING_REGISTER_DST_REPLACE: _bindgen_ty_3 = _bindgen_ty_3::IORING_REGISTER_DST_REPLACE;
+pub const IORING_REG_WAIT_TS: _bindgen_ty_4 = _bindgen_ty_4::IORING_REG_WAIT_TS;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum fsconfig_command {
+FSCONFIG_SET_FLAG = 0,
+FSCONFIG_SET_STRING = 1,
+FSCONFIG_SET_BINARY = 2,
+FSCONFIG_SET_PATH = 3,
+FSCONFIG_SET_PATH_EMPTY = 4,
+FSCONFIG_SET_FD = 5,
+FSCONFIG_CMD_CREATE = 6,
+FSCONFIG_CMD_RECONFIGURE = 7,
+FSCONFIG_CMD_CREATE_EXCL = 8,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum procmap_query_flags {
+PROCMAP_QUERY_VMA_READABLE = 1,
+PROCMAP_QUERY_VMA_WRITABLE = 2,
+PROCMAP_QUERY_VMA_EXECUTABLE = 4,
+PROCMAP_QUERY_VMA_SHARED = 8,
+PROCMAP_QUERY_COVERING_OR_NEXT_VMA = 16,
+PROCMAP_QUERY_FILE_BACKED_VMA = 32,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_sqe_flags_bit {
+IOSQE_FIXED_FILE_BIT = 0,
+IOSQE_IO_DRAIN_BIT = 1,
+IOSQE_IO_LINK_BIT = 2,
+IOSQE_IO_HARDLINK_BIT = 3,
+IOSQE_ASYNC_BIT = 4,
+IOSQE_BUFFER_SELECT_BIT = 5,
+IOSQE_CQE_SKIP_SUCCESS_BIT = 6,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_op {
+IORING_OP_NOP = 0,
+IORING_OP_READV = 1,
+IORING_OP_WRITEV = 2,
+IORING_OP_FSYNC = 3,
+IORING_OP_READ_FIXED = 4,
+IORING_OP_WRITE_FIXED = 5,
+IORING_OP_POLL_ADD = 6,
+IORING_OP_POLL_REMOVE = 7,
+IORING_OP_SYNC_FILE_RANGE = 8,
+IORING_OP_SENDMSG = 9,
+IORING_OP_RECVMSG = 10,
+IORING_OP_TIMEOUT = 11,
+IORING_OP_TIMEOUT_REMOVE = 12,
+IORING_OP_ACCEPT = 13,
+IORING_OP_ASYNC_CANCEL = 14,
+IORING_OP_LINK_TIMEOUT = 15,
+IORING_OP_CONNECT = 16,
+IORING_OP_FALLOCATE = 17,
+IORING_OP_OPENAT = 18,
+IORING_OP_CLOSE = 19,
+IORING_OP_FILES_UPDATE = 20,
+IORING_OP_STATX = 21,
+IORING_OP_READ = 22,
+IORING_OP_WRITE = 23,
+IORING_OP_FADVISE = 24,
+IORING_OP_MADVISE = 25,
+IORING_OP_SEND = 26,
+IORING_OP_RECV = 27,
+IORING_OP_OPENAT2 = 28,
+IORING_OP_EPOLL_CTL = 29,
+IORING_OP_SPLICE = 30,
+IORING_OP_PROVIDE_BUFFERS = 31,
+IORING_OP_REMOVE_BUFFERS = 32,
+IORING_OP_TEE = 33,
+IORING_OP_SHUTDOWN = 34,
+IORING_OP_RENAMEAT = 35,
+IORING_OP_UNLINKAT = 36,
+IORING_OP_MKDIRAT = 37,
+IORING_OP_SYMLINKAT = 38,
+IORING_OP_LINKAT = 39,
+IORING_OP_MSG_RING = 40,
+IORING_OP_FSETXATTR = 41,
+IORING_OP_SETXATTR = 42,
+IORING_OP_FGETXATTR = 43,
+IORING_OP_GETXATTR = 44,
+IORING_OP_SOCKET = 45,
+IORING_OP_URING_CMD = 46,
+IORING_OP_SEND_ZC = 47,
+IORING_OP_SENDMSG_ZC = 48,
+IORING_OP_READ_MULTISHOT = 49,
+IORING_OP_WAITID = 50,
+IORING_OP_FUTEX_WAIT = 51,
+IORING_OP_FUTEX_WAKE = 52,
+IORING_OP_FUTEX_WAITV = 53,
+IORING_OP_FIXED_FD_INSTALL = 54,
+IORING_OP_FTRUNCATE = 55,
+IORING_OP_BIND = 56,
+IORING_OP_LISTEN = 57,
+IORING_OP_RECV_ZC = 58,
+IORING_OP_EPOLL_WAIT = 59,
+IORING_OP_READV_FIXED = 60,
+IORING_OP_WRITEV_FIXED = 61,
+IORING_OP_PIPE = 62,
+IORING_OP_LAST = 63,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_msg_ring_flags {
+IORING_MSG_DATA = 0,
+IORING_MSG_SEND_FD = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_op {
+IORING_REGISTER_BUFFERS = 0,
+IORING_UNREGISTER_BUFFERS = 1,
+IORING_REGISTER_FILES = 2,
+IORING_UNREGISTER_FILES = 3,
+IORING_REGISTER_EVENTFD = 4,
+IORING_UNREGISTER_EVENTFD = 5,
+IORING_REGISTER_FILES_UPDATE = 6,
+IORING_REGISTER_EVENTFD_ASYNC = 7,
+IORING_REGISTER_PROBE = 8,
+IORING_REGISTER_PERSONALITY = 9,
+IORING_UNREGISTER_PERSONALITY = 10,
+IORING_REGISTER_RESTRICTIONS = 11,
+IORING_REGISTER_ENABLE_RINGS = 12,
+IORING_REGISTER_FILES2 = 13,
+IORING_REGISTER_FILES_UPDATE2 = 14,
+IORING_REGISTER_BUFFERS2 = 15,
+IORING_REGISTER_BUFFERS_UPDATE = 16,
+IORING_REGISTER_IOWQ_AFF = 17,
+IORING_UNREGISTER_IOWQ_AFF = 18,
+IORING_REGISTER_IOWQ_MAX_WORKERS = 19,
+IORING_REGISTER_RING_FDS = 20,
+IORING_UNREGISTER_RING_FDS = 21,
+IORING_REGISTER_PBUF_RING = 22,
+IORING_UNREGISTER_PBUF_RING = 23,
+IORING_REGISTER_SYNC_CANCEL = 24,
+IORING_REGISTER_FILE_ALLOC_RANGE = 25,
+IORING_REGISTER_PBUF_STATUS = 26,
+IORING_REGISTER_NAPI = 27,
+IORING_UNREGISTER_NAPI = 28,
+IORING_REGISTER_CLOCK = 29,
+IORING_REGISTER_CLONE_BUFFERS = 30,
+IORING_REGISTER_SEND_MSG_RING = 31,
+IORING_REGISTER_ZCRX_IFQ = 32,
+IORING_REGISTER_RESIZE_RINGS = 33,
+IORING_REGISTER_MEM_REGION = 34,
+IORING_REGISTER_LAST = 35,
+IORING_REGISTER_USE_REGISTERED_RING = 2147483648,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_wq_type {
+IO_WQ_BOUND = 0,
+IO_WQ_UNBOUND = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_1 {
+IORING_MEM_REGION_TYPE_USER = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_2 {
+IORING_MEM_REGION_REG_WAIT_ARG = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_3 {
+IORING_REGISTER_SRC_REGISTERED = 1,
+IORING_REGISTER_DST_REPLACE = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_pbuf_ring_flags {
+IOU_PBUF_RING_MMAP = 1,
+IOU_PBUF_RING_INC = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_napi_op {
+IO_URING_NAPI_REGISTER_OP = 0,
+IO_URING_NAPI_STATIC_ADD_ID = 1,
+IO_URING_NAPI_STATIC_DEL_ID = 2,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_napi_tracking_strategy {
+IO_URING_NAPI_TRACKING_DYNAMIC = 0,
+IO_URING_NAPI_TRACKING_STATIC = 1,
+IO_URING_NAPI_TRACKING_INACTIVE = 255,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_register_restriction_op {
+IORING_RESTRICTION_REGISTER_OP = 0,
+IORING_RESTRICTION_SQE_OP = 1,
+IORING_RESTRICTION_SQE_FLAGS_ALLOWED = 2,
+IORING_RESTRICTION_SQE_FLAGS_REQUIRED = 3,
+IORING_RESTRICTION_LAST = 4,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum _bindgen_ty_4 {
+IORING_REG_WAIT_TS = 1,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_socket_op {
+SOCKET_URING_OP_SIOCINQ = 0,
+SOCKET_URING_OP_SIOCOUTQ = 1,
+SOCKET_URING_OP_GETSOCKOPT = 2,
+SOCKET_URING_OP_SETSOCKOPT = 3,
+}
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum io_uring_zcrx_area_flags {
+IORING_ZCRX_AREA_DMABUF = 1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_get_policy_ex_arg__bindgen_ty_1 {
+pub version: __u8,
+pub v1: fscrypt_policy_v1,
+pub v2: fscrypt_policy_v2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union fscrypt_key_specifier__bindgen_ty_1 {
+pub __reserved: [__u8; 32usize],
+pub descriptor: [__u8; 8usize],
+pub identifier: [__u8; 16usize],
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_1 {
+pub off: __u64,
+pub addr2: __u64,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_1__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_2 {
+pub addr: __u64,
+pub splice_off_in: __u64,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_2__bindgen_ty_1,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_3 {
+pub rw_flags: __kernel_rwf_t,
+pub fsync_flags: __u32,
+pub poll_events: __u16,
+pub poll32_events: __u32,
+pub sync_range_flags: __u32,
+pub msg_flags: __u32,
+pub timeout_flags: __u32,
+pub accept_flags: __u32,
+pub cancel_flags: __u32,
+pub open_flags: __u32,
+pub statx_flags: __u32,
+pub fadvise_advice: __u32,
+pub splice_flags: __u32,
+pub rename_flags: __u32,
+pub unlink_flags: __u32,
+pub hardlink_flags: __u32,
+pub xattr_flags: __u32,
+pub msg_ring_flags: __u32,
+pub uring_cmd_flags: __u32,
+pub waitid_flags: __u32,
+pub futex_flags: __u32,
+pub install_fd_flags: __u32,
+pub nop_flags: __u32,
+pub pipe_flags: __u32,
+}
+#[repr(C, packed)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_4 {
+pub buf_index: __u16,
+pub buf_group: __u16,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_sqe__bindgen_ty_5 {
+pub splice_fd_in: __s32,
+pub file_index: __u32,
+pub zcrx_ifq_idx: __u32,
+pub optlen: __u32,
+pub __bindgen_anon_1: io_uring_sqe__bindgen_ty_5__bindgen_ty_1,
+pub __bindgen_anon_2: io_uring_sqe__bindgen_ty_5__bindgen_ty_2,
+}
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub union io_uring_restriction__bindgen_ty_1 {
+pub register_op: __u8,
+pub sqe_op: __u8,
+pub sqe_flags: __u8,
+}
+impl<T> __IncompleteArrayField<T> {
+#[inline]
+pub const fn new() -> Self {
+__IncompleteArrayField(::core::marker::PhantomData, [])
+}
+#[inline]
+pub fn as_ptr(&self) -> *const T {
+self as *const _ as *const T
+}
+#[inline]
+pub fn as_mut_ptr(&mut self) -> *mut T {
+self as *mut _ as *mut T
+}
+#[inline]
+pub unsafe fn as_slice(&self, len: usize) -> &[T] {
+::core::slice::from_raw_parts(self.as_ptr(), len)
+}
+#[inline]
+pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
+::core::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
+}
+}
+impl<T> ::core::fmt::Debug for __IncompleteArrayField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__IncompleteArrayField")
+}
+}
+impl<T> __BindgenUnionField<T> {
+#[inline]
+pub const fn new() -> Self {
+__BindgenUnionField(::core::marker::PhantomData)
+}
+#[inline]
+pub unsafe fn as_ref(&self) -> &T {
+::core::mem::transmute(self)
+}
+#[inline]
+pub unsafe fn as_mut(&mut self) -> &mut T {
+::core::mem::transmute(self)
+}
+}
+impl<T> ::core::default::Default for __BindgenUnionField<T> {
+#[inline]
+fn default() -> Self {
+Self::new()
+}
+}
+impl<T> ::core::clone::Clone for __BindgenUnionField<T> {
+#[inline]
+fn clone(&self) -> Self {
+*self
+}
+}
+impl<T> ::core::marker::Copy for __BindgenUnionField<T> {}
+impl<T> ::core::fmt::Debug for __BindgenUnionField<T> {
+fn fmt(&self, fmt: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+fmt.write_str("__BindgenUnionField")
+}
+}
+impl<T> ::core::hash::Hash for __BindgenUnionField<T> {
+fn hash<H: ::core::hash::Hasher>(&self, _state: &mut H) {}
+}
+impl<T> ::core::cmp::PartialEq for __BindgenUnionField<T> {
+fn eq(&self, _other: &__BindgenUnionField<T>) -> bool {
+true
+}
+}
+impl<T> ::core::cmp::Eq for __BindgenUnionField<T> {}

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/ioctl.rs

@@ -0,0 +1,1489 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub const FIONREAD: u32 = 21531;
+pub const FIONBIO: u32 = 21537;
+pub const FIOCLEX: u32 = 21585;
+pub const FIONCLEX: u32 = 21584;
+pub const FIOASYNC: u32 = 21586;
+pub const FIOQSIZE: u32 = 21600;
+pub const TCXONC: u32 = 21514;
+pub const TCFLSH: u32 = 21515;
+pub const TIOCSCTTY: u32 = 21518;
+pub const TIOCSPGRP: u32 = 21520;
+pub const TIOCOUTQ: u32 = 21521;
+pub const TIOCSTI: u32 = 21522;
+pub const TIOCSWINSZ: u32 = 21524;
+pub const TIOCMGET: u32 = 21525;
+pub const TIOCMBIS: u32 = 21526;
+pub const TIOCMBIC: u32 = 21527;
+pub const TIOCMSET: u32 = 21528;
+pub const TIOCSSOFTCAR: u32 = 21530;
+pub const TIOCLINUX: u32 = 21532;
+pub const TIOCCONS: u32 = 21533;
+pub const TIOCSSERIAL: u32 = 21535;
+pub const TIOCPKT: u32 = 21536;
+pub const TIOCNOTTY: u32 = 21538;
+pub const TIOCSETD: u32 = 21539;
+pub const TIOCSBRK: u32 = 21543;
+pub const TIOCCBRK: u32 = 21544;
+pub const TIOCSRS485: u32 = 21551;
+pub const TIOCSPTLCK: u32 = 1074025521;
+pub const TIOCSIG: u32 = 1074025526;
+pub const TIOCVHANGUP: u32 = 21559;
+pub const TIOCSERCONFIG: u32 = 21587;
+pub const TIOCSERGWILD: u32 = 21588;
+pub const TIOCSERSWILD: u32 = 21589;
+pub const TIOCSLCKTRMIOS: u32 = 21591;
+pub const TIOCSERGSTRUCT: u32 = 21592;
+pub const TIOCSERGETLSR: u32 = 21593;
+pub const TIOCSERGETMULTI: u32 = 21594;
+pub const TIOCSERSETMULTI: u32 = 21595;
+pub const TIOCMIWAIT: u32 = 21596;
+pub const TCGETS: u32 = 21505;
+pub const TCGETA: u32 = 21509;
+pub const TCSBRK: u32 = 21513;
+pub const TCSBRKP: u32 = 21541;
+pub const TCSETA: u32 = 21510;
+pub const TCSETAF: u32 = 21512;
+pub const TCSETAW: u32 = 21511;
+pub const TIOCEXCL: u32 = 21516;
+pub const TIOCNXCL: u32 = 21517;
+pub const TIOCGDEV: u32 = 2147767346;
+pub const TIOCGEXCL: u32 = 2147767360;
+pub const TIOCGICOUNT: u32 = 21597;
+pub const TIOCGLCKTRMIOS: u32 = 21590;
+pub const TIOCGPGRP: u32 = 21519;
+pub const TIOCGPKT: u32 = 2147767352;
+pub const TIOCGPTLCK: u32 = 2147767353;
+pub const TIOCGPTN: u32 = 2147767344;
+pub const TIOCGPTPEER: u32 = 21569;
+pub const TIOCGRS485: u32 = 21550;
+pub const TIOCGSERIAL: u32 = 21534;
+pub const TIOCGSID: u32 = 21545;
+pub const TIOCGSOFTCAR: u32 = 21529;
+pub const TIOCGWINSZ: u32 = 21523;
+pub const TCGETS2: u32 = 2150388778;
+pub const TCGETX: u32 = 21554;
+pub const TCSETS: u32 = 21506;
+pub const TCSETS2: u32 = 1076646955;
+pub const TCSETSF: u32 = 21508;
+pub const TCSETSF2: u32 = 1076646957;
+pub const TCSETSW: u32 = 21507;
+pub const TCSETSW2: u32 = 1076646956;
+pub const TCSETX: u32 = 21555;
+pub const TCSETXF: u32 = 21556;
+pub const TCSETXW: u32 = 21557;
+pub const TIOCGETD: u32 = 21540;
+pub const MTIOCGET: u32 = 2150657282;
+pub const BLKSSZGET: u32 = 4712;
+pub const BLKPBSZGET: u32 = 4731;
+pub const BLKROSET: u32 = 4701;
+pub const BLKROGET: u32 = 4702;
+pub const BLKRRPART: u32 = 4703;
+pub const BLKGETSIZE: u32 = 4704;
+pub const BLKFLSBUF: u32 = 4705;
+pub const BLKRASET: u32 = 4706;
+pub const BLKRAGET: u32 = 4707;
+pub const BLKFRASET: u32 = 4708;
+pub const BLKFRAGET: u32 = 4709;
+pub const BLKSECTSET: u32 = 4710;
+pub const BLKSECTGET: u32 = 4711;
+pub const BLKPG: u32 = 4713;
+pub const BLKBSZGET: u32 = 2148012656;
+pub const BLKBSZSET: u32 = 1074270833;
+pub const BLKGETSIZE64: u32 = 2148012658;
+pub const BLKTRACESETUP: u32 = 3225948787;
+pub const BLKTRACESTART: u32 = 4724;
+pub const BLKTRACESTOP: u32 = 4725;
+pub const BLKTRACETEARDOWN: u32 = 4726;
+pub const BLKDISCARD: u32 = 4727;
+pub const BLKIOMIN: u32 = 4728;
+pub const BLKIOOPT: u32 = 4729;
+pub const BLKALIGNOFF: u32 = 4730;
+pub const BLKDISCARDZEROES: u32 = 4732;
+pub const BLKSECDISCARD: u32 = 4733;
+pub const BLKROTATIONAL: u32 = 4734;
+pub const BLKZEROOUT: u32 = 4735;
+pub const UFFDIO_REGISTER: u32 = 3223366144;
+pub const UFFDIO_UNREGISTER: u32 = 2148575745;
+pub const UFFDIO_WAKE: u32 = 2148575746;
+pub const UFFDIO_COPY: u32 = 3223890435;
+pub const UFFDIO_ZEROPAGE: u32 = 3223366148;
+pub const UFFDIO_WRITEPROTECT: u32 = 3222841862;
+pub const UFFDIO_API: u32 = 3222841919;
+pub const NS_GET_USERNS: u32 = 46849;
+pub const NS_GET_PARENT: u32 = 46850;
+pub const NS_GET_NSTYPE: u32 = 46851;
+pub const KDGETLED: u32 = 19249;
+pub const KDSETLED: u32 = 19250;
+pub const KDGKBLED: u32 = 19300;
+pub const KDSKBLED: u32 = 19301;
+pub const KDGKBTYPE: u32 = 19251;
+pub const KDADDIO: u32 = 19252;
+pub const KDDELIO: u32 = 19253;
+pub const KDENABIO: u32 = 19254;
+pub const KDDISABIO: u32 = 19255;
+pub const KDSETMODE: u32 = 19258;
+pub const KDGETMODE: u32 = 19259;
+pub const KDMKTONE: u32 = 19248;
+pub const KIOCSOUND: u32 = 19247;
+pub const GIO_CMAP: u32 = 19312;
+pub const PIO_CMAP: u32 = 19313;
+pub const GIO_FONT: u32 = 19296;
+pub const GIO_FONTX: u32 = 19307;
+pub const PIO_FONT: u32 = 19297;
+pub const PIO_FONTX: u32 = 19308;
+pub const PIO_FONTRESET: u32 = 19309;
+pub const GIO_SCRNMAP: u32 = 19264;
+pub const GIO_UNISCRNMAP: u32 = 19305;
+pub const PIO_SCRNMAP: u32 = 19265;
+pub const PIO_UNISCRNMAP: u32 = 19306;
+pub const GIO_UNIMAP: u32 = 19302;
+pub const PIO_UNIMAP: u32 = 19303;
+pub const PIO_UNIMAPCLR: u32 = 19304;
+pub const KDGKBMODE: u32 = 19268;
+pub const KDSKBMODE: u32 = 19269;
+pub const KDGKBMETA: u32 = 19298;
+pub const KDSKBMETA: u32 = 19299;
+pub const KDGKBENT: u32 = 19270;
+pub const KDSKBENT: u32 = 19271;
+pub const KDGKBSENT: u32 = 19272;
+pub const KDSKBSENT: u32 = 19273;
+pub const KDGKBDIACR: u32 = 19274;
+pub const KDGETKEYCODE: u32 = 19276;
+pub const KDSETKEYCODE: u32 = 19277;
+pub const KDSIGACCEPT: u32 = 19278;
+pub const VT_OPENQRY: u32 = 22016;
+pub const VT_GETMODE: u32 = 22017;
+pub const VT_SETMODE: u32 = 22018;
+pub const VT_GETSTATE: u32 = 22019;
+pub const VT_RELDISP: u32 = 22021;
+pub const VT_ACTIVATE: u32 = 22022;
+pub const VT_WAITACTIVE: u32 = 22023;
+pub const VT_DISALLOCATE: u32 = 22024;
+pub const VT_RESIZE: u32 = 22025;
+pub const VT_RESIZEX: u32 = 22026;
+pub const FIOSETOWN: u32 = 35073;
+pub const SIOCSPGRP: u32 = 35074;
+pub const FIOGETOWN: u32 = 35075;
+pub const SIOCGPGRP: u32 = 35076;
+pub const SIOCATMARK: u32 = 35077;
+pub const SIOCGSTAMP: u32 = 35078;
+pub const TIOCINQ: u32 = 21531;
+pub const SIOCADDRT: u32 = 35083;
+pub const SIOCDELRT: u32 = 35084;
+pub const SIOCGIFNAME: u32 = 35088;
+pub const SIOCSIFLINK: u32 = 35089;
+pub const SIOCGIFCONF: u32 = 35090;
+pub const SIOCGIFFLAGS: u32 = 35091;
+pub const SIOCSIFFLAGS: u32 = 35092;
+pub const SIOCGIFADDR: u32 = 35093;
+pub const SIOCSIFADDR: u32 = 35094;
+pub const SIOCGIFDSTADDR: u32 = 35095;
+pub const SIOCSIFDSTADDR: u32 = 35096;
+pub const SIOCGIFBRDADDR: u32 = 35097;
+pub const SIOCSIFBRDADDR: u32 = 35098;
+pub const SIOCGIFNETMASK: u32 = 35099;
+pub const SIOCSIFNETMASK: u32 = 35100;
+pub const SIOCGIFMETRIC: u32 = 35101;
+pub const SIOCSIFMETRIC: u32 = 35102;
+pub const SIOCGIFMEM: u32 = 35103;
+pub const SIOCSIFMEM: u32 = 35104;
+pub const SIOCGIFMTU: u32 = 35105;
+pub const SIOCSIFMTU: u32 = 35106;
+pub const SIOCSIFHWADDR: u32 = 35108;
+pub const SIOCGIFENCAP: u32 = 35109;
+pub const SIOCSIFENCAP: u32 = 35110;
+pub const SIOCGIFHWADDR: u32 = 35111;
+pub const SIOCGIFSLAVE: u32 = 35113;
+pub const SIOCSIFSLAVE: u32 = 35120;
+pub const SIOCADDMULTI: u32 = 35121;
+pub const SIOCDELMULTI: u32 = 35122;
+pub const SIOCDARP: u32 = 35155;
+pub const SIOCGARP: u32 = 35156;
+pub const SIOCSARP: u32 = 35157;
+pub const SIOCDRARP: u32 = 35168;
+pub const SIOCGRARP: u32 = 35169;
+pub const SIOCSRARP: u32 = 35170;
+pub const SIOCGIFMAP: u32 = 35184;
+pub const SIOCSIFMAP: u32 = 35185;
+pub const SIOCRTMSG: u32 = 35085;
+pub const SIOCSIFNAME: u32 = 35107;
+pub const SIOCGIFINDEX: u32 = 35123;
+pub const SIOGIFINDEX: u32 = 35123;
+pub const SIOCSIFPFLAGS: u32 = 35124;
+pub const SIOCGIFPFLAGS: u32 = 35125;
+pub const SIOCDIFADDR: u32 = 35126;
+pub const SIOCSIFHWBROADCAST: u32 = 35127;
+pub const SIOCGIFCOUNT: u32 = 35128;
+pub const SIOCGIFBR: u32 = 35136;
+pub const SIOCSIFBR: u32 = 35137;
+pub const SIOCGIFTXQLEN: u32 = 35138;
+pub const SIOCSIFTXQLEN: u32 = 35139;
+pub const SIOCADDDLCI: u32 = 35200;
+pub const SIOCDELDLCI: u32 = 35201;
+pub const SIOCDEVPRIVATE: u32 = 35312;
+pub const SIOCPROTOPRIVATE: u32 = 35296;
+pub const FIBMAP: u32 = 1;
+pub const FIGETBSZ: u32 = 2;
+pub const FIFREEZE: u32 = 3221510263;
+pub const FITHAW: u32 = 3221510264;
+pub const FITRIM: u32 = 3222820985;
+pub const FICLONE: u32 = 1074041865;
+pub const FICLONERANGE: u32 = 1075876877;
+pub const FIDEDUPERANGE: u32 = 3222836278;
+pub const FS_IOC_GETFLAGS: u32 = 2148034049;
+pub const FS_IOC_SETFLAGS: u32 = 1074292226;
+pub const FS_IOC_GETVERSION: u32 = 2148038145;
+pub const FS_IOC_SETVERSION: u32 = 1074296322;
+pub const FS_IOC_FIEMAP: u32 = 3223348747;
+pub const FS_IOC32_GETFLAGS: u32 = 2147771905;
+pub const FS_IOC32_SETFLAGS: u32 = 1074030082;
+pub const FS_IOC32_GETVERSION: u32 = 2147776001;
+pub const FS_IOC32_SETVERSION: u32 = 1074034178;
+pub const FS_IOC_FSGETXATTR: u32 = 2149341215;
+pub const FS_IOC_FSSETXATTR: u32 = 1075599392;
+pub const FS_IOC_GETFSLABEL: u32 = 2164298801;
+pub const FS_IOC_SETFSLABEL: u32 = 1090556978;
+pub const EXT4_IOC_GETVERSION: u32 = 2148034051;
+pub const EXT4_IOC_SETVERSION: u32 = 1074292228;
+pub const EXT4_IOC_GETVERSION_OLD: u32 = 2148038145;
+pub const EXT4_IOC_SETVERSION_OLD: u32 = 1074296322;
+pub const EXT4_IOC_GETRSVSZ: u32 = 2148034053;
+pub const EXT4_IOC_SETRSVSZ: u32 = 1074292230;
+pub const EXT4_IOC_GROUP_EXTEND: u32 = 1074292231;
+pub const EXT4_IOC_MIGRATE: u32 = 26121;
+pub const EXT4_IOC_ALLOC_DA_BLKS: u32 = 26124;
+pub const EXT4_IOC_RESIZE_FS: u32 = 1074292240;
+pub const EXT4_IOC_SWAP_BOOT: u32 = 26129;
+pub const EXT4_IOC_PRECACHE_EXTENTS: u32 = 26130;
+pub const EXT4_IOC_CLEAR_ES_CACHE: u32 = 26152;
+pub const EXT4_IOC_GETSTATE: u32 = 1074030121;
+pub const EXT4_IOC_GET_ES_CACHE: u32 = 3223348778;
+pub const EXT4_IOC_CHECKPOINT: u32 = 1074030123;
+pub const EXT4_IOC_SHUTDOWN: u32 = 2147768445;
+pub const EXT4_IOC32_GETVERSION: u32 = 2147771907;
+pub const EXT4_IOC32_SETVERSION: u32 = 1074030084;
+pub const EXT4_IOC32_GETRSVSZ: u32 = 2147771909;
+pub const EXT4_IOC32_SETRSVSZ: u32 = 1074030086;
+pub const EXT4_IOC32_GROUP_EXTEND: u32 = 1074030087;
+pub const EXT4_IOC32_GETVERSION_OLD: u32 = 2147776001;
+pub const EXT4_IOC32_SETVERSION_OLD: u32 = 1074034178;
+pub const VIDIOC_SUBDEV_QUERYSTD: u32 = 2148030015;
+pub const AUTOFS_DEV_IOCTL_CLOSEMOUNT: u32 = 3222836085;
+pub const LIRC_SET_SEND_CARRIER: u32 = 1074030867;
+pub const AUTOFS_IOC_PROTOSUBVER: u32 = 2147783527;
+pub const PTP_SYS_OFFSET_PRECISE: u32 = 3225435400;
+pub const FSI_SCOM_WRITE: u32 = 3223352066;
+pub const ATM_GETCIRANGE: u32 = 1074815370;
+pub const DMA_BUF_SET_NAME_B: u32 = 1074291201;
+pub const RIO_CM_EP_GET_LIST_SIZE: u32 = 3221512961;
+pub const TUNSETPERSIST: u32 = 1074025675;
+pub const FS_IOC_GET_ENCRYPTION_POLICY: u32 = 1074554389;
+pub const CEC_RECEIVE: u32 = 3224920326;
+pub const MGSL_IOCGPARAMS: u32 = 2150657281;
+pub const ENI_SETMULT: u32 = 1074815335;
+pub const RIO_GET_EVENT_MASK: u32 = 2147773710;
+pub const LIRC_GET_MAX_TIMEOUT: u32 = 2147772681;
+pub const USBDEVFS_CLAIMINTERFACE: u32 = 2147767567;
+pub const CHIOMOVE: u32 = 1075077889;
+pub const SONYPI_IOCGBATFLAGS: u32 = 2147579399;
+pub const BTRFS_IOC_SYNC: u32 = 37896;
+pub const VIDIOC_TRY_FMT: u32 = 3234879040;
+pub const LIRC_SET_REC_MODE: u32 = 1074030866;
+pub const VIDIOC_DQEVENT: u32 = 2156418649;
+pub const RPMSG_DESTROY_EPT_IOCTL: u32 = 46338;
+pub const UVCIOC_CTRL_MAP: u32 = 3227546912;
+pub const VHOST_SET_BACKEND_FEATURES: u32 = 1074310949;
+pub const VHOST_VSOCK_SET_GUEST_CID: u32 = 1074311008;
+pub const UI_SET_KEYBIT: u32 = 1074025829;
+pub const LIRC_SET_REC_TIMEOUT: u32 = 1074030872;
+pub const FS_IOC_GET_ENCRYPTION_KEY_STATUS: u32 = 3229640218;
+pub const BTRFS_IOC_TREE_SEARCH_V2: u32 = 3228603409;
+pub const VHOST_SET_VRING_BASE: u32 = 1074310930;
+pub const RIO_ENABLE_DOORBELL_RANGE: u32 = 1074294025;
+pub const VIDIOC_TRY_EXT_CTRLS: u32 = 3223344713;
+pub const LIRC_GET_REC_MODE: u32 = 2147772674;
+pub const PPGETTIME: u32 = 2148561045;
+pub const BTRFS_IOC_RM_DEV: u32 = 1342215179;
+pub const ATM_SETBACKEND: u32 = 1073897970;
+pub const FSL_HV_IOCTL_PARTITION_START: u32 = 3222318851;
+pub const FBIO_WAITEVENT: u32 = 18056;
+pub const SWITCHTEC_IOCTL_PORT_TO_PFF: u32 = 3222034245;
+pub const NVME_IOCTL_IO_CMD: u32 = 3225964099;
+pub const IPMICTL_RECEIVE_MSG_TRUNC: u32 = 3224398091;
+pub const FDTWADDLE: u32 = 601;
+pub const NVME_IOCTL_SUBMIT_IO: u32 = 1076907586;
+pub const NILFS_IOCTL_SYNC: u32 = 2148036234;
+pub const VIDIOC_SUBDEV_S_DV_TIMINGS: u32 = 3229898327;
+pub const ASPEED_LPC_CTRL_IOCTL_GET_SIZE: u32 = 3222319616;
+pub const DM_DEV_STATUS: u32 = 3241737479;
+pub const TEE_IOC_CLOSE_SESSION: u32 = 2147787781;
+pub const NS_GETPSTAT: u32 = 3222298977;
+pub const UI_SET_PROPBIT: u32 = 1074025838;
+pub const TUNSETFILTEREBPF: u32 = 2147767521;
+pub const RIO_MPORT_MAINT_COMPTAG_SET: u32 = 1074031874;
+pub const AUTOFS_DEV_IOCTL_VERSION: u32 = 3222836081;
+pub const WDIOC_SETOPTIONS: u32 = 2147768068;
+pub const VHOST_SCSI_SET_ENDPOINT: u32 = 1088991040;
+pub const MGSL_IOCGTXIDLE: u32 = 27907;
+pub const ATM_ADDLECSADDR: u32 = 1074815374;
+pub const FSL_HV_IOCTL_GETPROP: u32 = 3223891719;
+pub const FDGETPRM: u32 = 2149581316;
+pub const HIDIOCAPPLICATION: u32 = 18434;
+pub const ENI_MEMDUMP: u32 = 1074815328;
+pub const PTP_SYS_OFFSET2: u32 = 1128283406;
+pub const VIDIOC_SUBDEV_G_DV_TIMINGS: u32 = 3229898328;
+pub const DMA_BUF_SET_NAME_A: u32 = 1074029057;
+pub const PTP_PIN_GETFUNC: u32 = 3227532550;
+pub const PTP_SYS_OFFSET_EXTENDED: u32 = 3300932873;
+pub const DFL_FPGA_PORT_UINT_SET_IRQ: u32 = 1074312776;
+pub const RTC_EPOCH_READ: u32 = 2148036621;
+pub const VIDIOC_SUBDEV_S_SELECTION: u32 = 3225441854;
+pub const VIDIOC_QUERY_EXT_CTRL: u32 = 3236451943;
+pub const ATM_GETLECSADDR: u32 = 1074815376;
+pub const FSL_HV_IOCTL_PARTITION_STOP: u32 = 3221794564;
+pub const SONET_GETDIAG: u32 = 2147770644;
+pub const ATMMPC_DATA: u32 = 25049;
+pub const IPMICTL_UNREGISTER_FOR_CMD_CHANS: u32 = 2148296989;
+pub const HIDIOCGCOLLECTIONINDEX: u32 = 1075333136;
+pub const RPMSG_CREATE_EPT_IOCTL: u32 = 1076409601;
+pub const GPIOHANDLE_GET_LINE_VALUES_IOCTL: u32 = 3225465864;
+pub const UI_DEV_SETUP: u32 = 1079792899;
+pub const ISST_IF_IO_CMD: u32 = 1074331138;
+pub const RIO_MPORT_MAINT_READ_REMOTE: u32 = 2149084423;
+pub const VIDIOC_OMAP3ISP_HIST_CFG: u32 = 3224393412;
+pub const BLKGETNRZONES: u32 = 2147750533;
+pub const VIDIOC_G_MODULATOR: u32 = 3225703990;
+pub const VBG_IOCTL_WRITE_CORE_DUMP: u32 = 3223082515;
+pub const USBDEVFS_SETINTERFACE: u32 = 2148029700;
+pub const PPPIOCGCHAN: u32 = 2147775543;
+pub const EVIOCGVERSION: u32 = 2147763457;
+pub const VHOST_NET_SET_BACKEND: u32 = 1074310960;
+pub const USBDEVFS_REAPURBNDELAY: u32 = 1074287885;
+pub const RNDZAPENTCNT: u32 = 20996;
+pub const VIDIOC_G_PARM: u32 = 3234616853;
+pub const TUNGETDEVNETNS: u32 = 21731;
+pub const LIRC_SET_MEASURE_CARRIER_MODE: u32 = 1074030877;
+pub const VHOST_SET_VRING_ERR: u32 = 1074310946;
+pub const VDUSE_VQ_SETUP: u32 = 1075872020;
+pub const AUTOFS_IOC_SETTIMEOUT: u32 = 3221787492;
+pub const VIDIOC_S_FREQUENCY: u32 = 1076647481;
+pub const F2FS_IOC_SEC_TRIM_FILE: u32 = 1075377428;
+pub const FS_IOC_REMOVE_ENCRYPTION_KEY: u32 = 3225445912;
+pub const WDIOC_GETPRETIMEOUT: u32 = 2147768073;
+pub const USBDEVFS_DROP_PRIVILEGES: u32 = 1074025758;
+pub const BTRFS_IOC_SNAP_CREATE_V2: u32 = 1342215191;
+pub const VHOST_VSOCK_SET_RUNNING: u32 = 1074048865;
+pub const STP_SET_OPTIONS: u32 = 1074275586;
+pub const FBIO_RADEON_GET_MIRROR: u32 = 2148024323;
+pub const IVTVFB_IOC_DMA_FRAME: u32 = 1075336896;
+pub const IPMICTL_SEND_COMMAND: u32 = 2150131981;
+pub const VIDIOC_G_ENC_INDEX: u32 = 2283296332;
+pub const DFL_FPGA_FME_PORT_PR: u32 = 46720;
+pub const CHIOSVOLTAG: u32 = 1076912914;
+pub const ATM_SETESIF: u32 = 1074815373;
+pub const FW_CDEV_IOC_SEND_RESPONSE: u32 = 1075323652;
+pub const PMU_IOC_GET_MODEL: u32 = 2148024835;
+pub const JSIOCGBTNMAP: u32 = 2214619700;
+pub const USBDEVFS_HUB_PORTINFO: u32 = 2155894035;
+pub const VBG_IOCTL_INTERRUPT_ALL_WAIT_FOR_EVENTS: u32 = 3222820363;
+pub const FDCLRPRM: u32 = 577;
+pub const BTRFS_IOC_SCRUB: u32 = 3288372251;
+pub const USBDEVFS_DISCONNECT: u32 = 21782;
+pub const TUNSETVNETBE: u32 = 1074025694;
+pub const ATMTCP_REMOVE: u32 = 24975;
+pub const VHOST_VDPA_GET_CONFIG: u32 = 2148052851;
+pub const PPPIOCGNPMODE: u32 = 3221779532;
+pub const FDGETDRVPRM: u32 = 2155872785;
+pub const TUNSETVNETLE: u32 = 1074025692;
+pub const PHN_SETREG: u32 = 1074294790;
+pub const PPPIOCDETACH: u32 = 1074033724;
+pub const MMTIMER_GETRES: u32 = 2148035841;
+pub const VIDIOC_SUBDEV_ENUMSTD: u32 = 3225966105;
+pub const PPGETFLAGS: u32 = 2147774618;
+pub const VDUSE_DEV_GET_FEATURES: u32 = 2148040977;
+pub const CAPI_MANUFACTURER_CMD: u32 = 3222291232;
+pub const VIDIOC_G_TUNER: u32 = 3226752541;
+pub const DM_TABLE_STATUS: u32 = 3241737484;
+pub const DM_DEV_ARM_POLL: u32 = 3241737488;
+pub const NE_CREATE_VM: u32 = 2148052512;
+pub const MEDIA_IOC_ENUM_LINKS: u32 = 3223878658;
+pub const F2FS_IOC_PRECACHE_EXTENTS: u32 = 62735;
+pub const DFL_FPGA_PORT_DMA_MAP: u32 = 46659;
+pub const MGSL_IOCGXCTRL: u32 = 27926;
+pub const FW_CDEV_IOC_SEND_REQUEST: u32 = 1076372225;
+pub const SONYPI_IOCGBLUE: u32 = 2147579400;
+pub const F2FS_IOC_DECOMPRESS_FILE: u32 = 62743;
+pub const I2OHTML: u32 = 3224398089;
+pub const VFIO_GET_API_VERSION: u32 = 15204;
+pub const IDT77105_GETSTATZ: u32 = 1074815283;
+pub const I2OPARMSET: u32 = 3223873795;
+pub const TEE_IOC_CANCEL: u32 = 2148049924;
+pub const PTP_SYS_OFFSET_PRECISE2: u32 = 3225435409;
+pub const DFL_FPGA_PORT_RESET: u32 = 46656;
+pub const PPPIOCGASYNCMAP: u32 = 2147775576;
+pub const EVIOCGKEYCODE_V2: u32 = 2150122756;
+pub const DM_DEV_SET_GEOMETRY: u32 = 3241737487;
+pub const HIDIOCSUSAGE: u32 = 1075333132;
+pub const FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE_ONCE: u32 = 1075323664;
+pub const PTP_EXTTS_REQUEST: u32 = 1074806018;
+pub const SWITCHTEC_IOCTL_EVENT_CTL: u32 = 3223869251;
+pub const WDIOC_SETPRETIMEOUT: u32 = 3221509896;
+pub const VHOST_SCSI_CLEAR_ENDPOINT: u32 = 1088991041;
+pub const JSIOCGAXES: u32 = 2147576337;
+pub const HIDIOCSFLAG: u32 = 1074022415;
+pub const PTP_PEROUT_REQUEST2: u32 = 1077427468;
+pub const PPWDATA: u32 = 1073836166;
+pub const PTP_CLOCK_GETCAPS: u32 = 2152742145;
+pub const FDGETMAXERRS: u32 = 2148794894;
+pub const TUNSETQUEUE: u32 = 1074025689;
+pub const PTP_ENABLE_PPS: u32 = 1074019588;
+pub const SIOCSIFATMTCP: u32 = 24960;
+pub const CEC_ADAP_G_LOG_ADDRS: u32 = 2153537795;
+pub const ND_IOCTL_ARS_CAP: u32 = 3223342593;
+pub const NBD_SET_BLKSIZE: u32 = 43777;
+pub const NBD_SET_TIMEOUT: u32 = 43785;
+pub const VHOST_SCSI_GET_ABI_VERSION: u32 = 1074048834;
+pub const RIO_UNMAP_INBOUND: u32 = 1074294034;
+pub const ATM_QUERYLOOP: u32 = 1074815316;
+pub const DFL_FPGA_GET_API_VERSION: u32 = 46592;
+pub const USBDEVFS_WAIT_FOR_RESUME: u32 = 21795;
+pub const FBIO_CURSOR: u32 = 3228059144;
+pub const RNDCLEARPOOL: u32 = 20998;
+pub const VIDIOC_QUERYSTD: u32 = 2148030015;
+pub const DMA_BUF_IOCTL_SYNC: u32 = 1074291200;
+pub const SCIF_RECV: u32 = 3222827783;
+pub const PTP_PIN_GETFUNC2: u32 = 3227532559;
+pub const FW_CDEV_IOC_ALLOCATE: u32 = 3223331586;
+pub const CEC_ADAP_G_CAPS: u32 = 3226231040;
+pub const VIDIOC_G_FBUF: u32 = 2150651402;
+pub const PTP_ENABLE_PPS2: u32 = 1074019597;
+pub const PCITEST_CLEAR_IRQ: u32 = 20496;
+pub const IPMICTL_SET_GETS_EVENTS_CMD: u32 = 2147772688;
+pub const BTRFS_IOC_DEVICES_READY: u32 = 2415957031;
+pub const JSIOCGAXMAP: u32 = 2151705138;
+pub const FW_CDEV_IOC_GET_CYCLE_TIMER: u32 = 2148541196;
+pub const FW_CDEV_IOC_SET_ISO_CHANNELS: u32 = 1074799383;
+pub const RTC_WIE_OFF: u32 = 28688;
+pub const PPGETMODE: u32 = 2147774616;
+pub const VIDIOC_DBG_G_REGISTER: u32 = 3224917584;
+pub const PTP_SYS_OFFSET: u32 = 1128283397;
+pub const BTRFS_IOC_SPACE_INFO: u32 = 3222311956;
+pub const VIDIOC_SUBDEV_ENUM_FRAME_SIZE: u32 = 3225441866;
+pub const ND_IOCTL_VENDOR: u32 = 3221769737;
+pub const SCIF_VREADFROM: u32 = 3223876364;
+pub const BTRFS_IOC_TRANS_START: u32 = 37894;
+pub const INOTIFY_IOC_SETNEXTWD: u32 = 1074022656;
+pub const SNAPSHOT_GET_IMAGE_SIZE: u32 = 2148021006;
+pub const TUNDETACHFILTER: u32 = 1074812118;
+pub const ND_IOCTL_CLEAR_ERROR: u32 = 3223342596;
+pub const IOC_PR_CLEAR: u32 = 1074819277;
+pub const SCIF_READFROM: u32 = 3223876362;
+pub const PPPIOCGDEBUG: u32 = 2147775553;
+pub const BLKGETZONESZ: u32 = 2147750532;
+pub const HIDIOCGUSAGES: u32 = 3491514387;
+pub const SONYPI_IOCGTEMP: u32 = 2147579404;
+pub const UI_SET_MSCBIT: u32 = 1074025832;
+pub const APM_IOC_SUSPEND: u32 = 16642;
+pub const BTRFS_IOC_TREE_SEARCH: u32 = 3489698833;
+pub const RTC_PLL_GET: u32 = 2149609489;
+pub const RIO_CM_EP_GET_LIST: u32 = 3221512962;
+pub const USBDEVFS_DISCSIGNAL: u32 = 2148553998;
+pub const LIRC_GET_MIN_TIMEOUT: u32 = 2147772680;
+pub const SWITCHTEC_IOCTL_EVENT_SUMMARY_LEGACY: u32 = 2174244674;
+pub const DM_TARGET_MSG: u32 = 3241737486;
+pub const SONYPI_IOCGBAT1REM: u32 = 2147644931;
+pub const EVIOCSFF: u32 = 1076905344;
+pub const TUNSETGROUP: u32 = 1074025678;
+pub const EVIOCGKEYCODE: u32 = 2148025604;
+pub const KCOV_REMOTE_ENABLE: u32 = 1075340134;
+pub const ND_IOCTL_GET_CONFIG_SIZE: u32 = 3222031876;
+pub const FDEJECT: u32 = 602;
+pub const TUNSETOFFLOAD: u32 = 1074025680;
+pub const PPPIOCCONNECT: u32 = 1074033722;
+pub const ATM_ADDADDR: u32 = 1074815368;
+pub const VDUSE_DEV_INJECT_CONFIG_IRQ: u32 = 33043;
+pub const AUTOFS_DEV_IOCTL_ASKUMOUNT: u32 = 3222836093;
+pub const VHOST_VDPA_GET_STATUS: u32 = 2147594097;
+pub const CCISS_PASSTHRU: u32 = 3227009547;
+pub const MGSL_IOCCLRMODCOUNT: u32 = 27919;
+pub const TEE_IOC_SUPPL_SEND: u32 = 2148574215;
+pub const ATMARPD_CTRL: u32 = 25057;
+pub const UI_ABS_SETUP: u32 = 1075598596;
+pub const UI_DEV_DESTROY: u32 = 21762;
+pub const BTRFS_IOC_QUOTA_CTL: u32 = 3222311976;
+pub const RTC_AIE_ON: u32 = 28673;
+pub const AUTOFS_IOC_EXPIRE: u32 = 2165085029;
+pub const PPPIOCSDEBUG: u32 = 1074033728;
+pub const GPIO_V2_LINE_SET_VALUES_IOCTL: u32 = 3222320143;
+pub const PPPIOCSMRU: u32 = 1074033746;
+pub const CCISS_DEREGDISK: u32 = 16908;
+pub const UI_DEV_CREATE: u32 = 21761;
+pub const FUSE_DEV_IOC_CLONE: u32 = 2147804416;
+pub const BTRFS_IOC_START_SYNC: u32 = 2148045848;
+pub const NILFS_IOCTL_DELETE_CHECKPOINT: u32 = 1074294401;
+pub const SNAPSHOT_AVAIL_SWAP_SIZE: u32 = 2148021011;
+pub const DM_TABLE_CLEAR: u32 = 3241737482;
+pub const CCISS_GETINTINFO: u32 = 2148024834;
+pub const PPPIOCSASYNCMAP: u32 = 1074033751;
+pub const I2OEVTGET: u32 = 2154326283;
+pub const NVME_IOCTL_RESET: u32 = 20036;
+pub const PPYIELD: u32 = 28813;
+pub const NVME_IOCTL_IO64_CMD: u32 = 3226488392;
+pub const TUNSETCARRIER: u32 = 1074025698;
+pub const DM_DEV_WAIT: u32 = 3241737480;
+pub const RTC_WIE_ON: u32 = 28687;
+pub const MEDIA_IOC_DEVICE_INFO: u32 = 3238034432;
+pub const RIO_CM_CHAN_CREATE: u32 = 3221381891;
+pub const MGSL_IOCSPARAMS: u32 = 1076915456;
+pub const RTC_SET_TIME: u32 = 1076129802;
+pub const VHOST_RESET_OWNER: u32 = 44802;
+pub const IOC_OPAL_PSID_REVERT_TPR: u32 = 1091072232;
+pub const AUTOFS_DEV_IOCTL_OPENMOUNT: u32 = 3222836084;
+pub const UDF_GETEABLOCK: u32 = 2148035649;
+pub const VFIO_IOMMU_MAP_DMA: u32 = 15217;
+pub const VIDIOC_SUBSCRIBE_EVENT: u32 = 1075861082;
+pub const HIDIOCGFLAG: u32 = 2147764238;
+pub const HIDIOCGUCODE: u32 = 3222816781;
+pub const VIDIOC_OMAP3ISP_AF_CFG: u32 = 3226228421;
+pub const DM_REMOVE_ALL: u32 = 3241737473;
+pub const ASPEED_LPC_CTRL_IOCTL_MAP: u32 = 1074835969;
+pub const CCISS_GETFIRMVER: u32 = 2147762696;
+pub const ND_IOCTL_ARS_START: u32 = 3223342594;
+pub const PPPIOCSMRRU: u32 = 1074033723;
+pub const CEC_ADAP_S_LOG_ADDRS: u32 = 3227279620;
+pub const RPROC_GET_SHUTDOWN_ON_RELEASE: u32 = 2147792642;
+pub const DMA_HEAP_IOCTL_ALLOC: u32 = 3222816768;
+pub const PPSETTIME: u32 = 1074819222;
+pub const RTC_ALM_READ: u32 = 2149871624;
+pub const VDUSE_SET_API_VERSION: u32 = 1074299137;
+pub const RIO_MPORT_MAINT_WRITE_REMOTE: u32 = 1075342600;
+pub const VIDIOC_SUBDEV_S_CROP: u32 = 3224917564;
+pub const USBDEVFS_CONNECT: u32 = 21783;
+pub const SYNC_IOC_FILE_INFO: u32 = 3224911364;
+pub const ATMARP_MKIP: u32 = 25058;
+pub const VFIO_IOMMU_SPAPR_TCE_GET_INFO: u32 = 15216;
+pub const CCISS_GETHEARTBEAT: u32 = 2147762694;
+pub const ATM_RSTADDR: u32 = 1074815367;
+pub const NBD_SET_SIZE: u32 = 43778;
+pub const UDF_GETVOLIDENT: u32 = 2148035650;
+pub const GPIO_V2_LINE_GET_VALUES_IOCTL: u32 = 3222320142;
+pub const MGSL_IOCSTXIDLE: u32 = 27906;
+pub const FSL_HV_IOCTL_SETPROP: u32 = 3223891720;
+pub const BTRFS_IOC_GET_DEV_STATS: u32 = 3288896564;
+pub const PPRSTATUS: u32 = 2147577985;
+pub const MGSL_IOCTXENABLE: u32 = 27908;
+pub const UDF_GETEASIZE: u32 = 2147773504;
+pub const NVME_IOCTL_ADMIN64_CMD: u32 = 3226488391;
+pub const VHOST_SET_OWNER: u32 = 44801;
+pub const RIO_ALLOC_DMA: u32 = 3222826259;
+pub const RIO_CM_CHAN_ACCEPT: u32 = 3221775111;
+pub const I2OHRTGET: u32 = 3222825217;
+pub const ATM_SETCIRANGE: u32 = 1074815371;
+pub const HPET_IE_ON: u32 = 26625;
+pub const PERF_EVENT_IOC_ID: u32 = 2148017159;
+pub const TUNSETSNDBUF: u32 = 1074025684;
+pub const PTP_PIN_SETFUNC: u32 = 1080048903;
+pub const PPPIOCDISCONN: u32 = 29753;
+pub const VIDIOC_QUERYCTRL: u32 = 3225703972;
+pub const PPEXCL: u32 = 28815;
+pub const PCITEST_MSI: u32 = 1074024451;
+pub const FDWERRORCLR: u32 = 598;
+pub const AUTOFS_IOC_FAIL: u32 = 37729;
+pub const USBDEVFS_IOCTL: u32 = 3222295826;
+pub const VIDIOC_S_STD: u32 = 1074288152;
+pub const F2FS_IOC_RESIZE_FS: u32 = 1074328848;
+pub const SONET_SETDIAG: u32 = 3221512466;
+pub const BTRFS_IOC_DEFRAG: u32 = 1342215170;
+pub const CCISS_GETDRIVVER: u32 = 2147762697;
+pub const IPMICTL_GET_TIMING_PARMS_CMD: u32 = 2148034839;
+pub const HPET_IRQFREQ: u32 = 1074292742;
+pub const ATM_GETESI: u32 = 1074815365;
+pub const CCISS_GETLUNINFO: u32 = 2148286993;
+pub const AUTOFS_DEV_IOCTL_ISMOUNTPOINT: u32 = 3222836094;
+pub const TEE_IOC_SHM_ALLOC: u32 = 3222316033;
+pub const PERF_EVENT_IOC_SET_BPF: u32 = 1074013192;
+pub const UDMABUF_CREATE_LIST: u32 = 1074296131;
+pub const VHOST_SET_LOG_BASE: u32 = 1074310916;
+pub const ZATM_GETPOOL: u32 = 1074815329;
+pub const BR2684_SETFILT: u32 = 1075601808;
+pub const RNDGETPOOL: u32 = 2148028930;
+pub const PPS_GETPARAMS: u32 = 2148036769;
+pub const IOC_PR_RESERVE: u32 = 1074819273;
+pub const VIDIOC_TRY_DECODER_CMD: u32 = 3225966177;
+pub const RIO_CM_CHAN_CLOSE: u32 = 1073898244;
+pub const VIDIOC_DV_TIMINGS_CAP: u32 = 3230684772;
+pub const IOCTL_MEI_CONNECT_CLIENT_VTAG: u32 = 3222554628;
+pub const PMU_IOC_GET_BACKLIGHT: u32 = 2148024833;
+pub const USBDEVFS_GET_CAPABILITIES: u32 = 2147767578;
+pub const SCIF_WRITETO: u32 = 3223876363;
+pub const UDF_RELOCATE_BLOCKS: u32 = 3221777475;
+pub const FSL_HV_IOCTL_PARTITION_RESTART: u32 = 3221794561;
+pub const CCISS_REGNEWD: u32 = 16910;
+pub const FAT_IOCTL_SET_ATTRIBUTES: u32 = 1074033169;
+pub const VIDIOC_CREATE_BUFS: u32 = 3238024796;
+pub const CAPI_GET_VERSION: u32 = 3222291207;
+pub const SWITCHTEC_IOCTL_EVENT_SUMMARY: u32 = 2228770626;
+pub const VFIO_EEH_PE_OP: u32 = 15225;
+pub const FW_CDEV_IOC_CREATE_ISO_CONTEXT: u32 = 3223331592;
+pub const F2FS_IOC_RELEASE_COMPRESS_BLOCKS: u32 = 2148070674;
+pub const NBD_SET_SIZE_BLOCKS: u32 = 43783;
+pub const IPMI_BMC_IOCTL_SET_SMS_ATN: u32 = 45312;
+pub const ASPEED_P2A_CTRL_IOCTL_GET_MEMORY_CONFIG: u32 = 3222319873;
+pub const VIDIOC_S_AUDOUT: u32 = 1077171762;
+pub const VIDIOC_S_FMT: u32 = 3234878981;
+pub const PPPIOCATTACH: u32 = 1074033725;
+pub const VHOST_GET_VRING_BUSYLOOP_TIMEOUT: u32 = 1074310948;
+pub const FS_IOC_MEASURE_VERITY: u32 = 3221513862;
+pub const CCISS_BIG_PASSTHRU: u32 = 3227533842;
+pub const IPMICTL_SET_MY_LUN_CMD: u32 = 2147772691;
+pub const PCITEST_LEGACY_IRQ: u32 = 20482;
+pub const USBDEVFS_SUBMITURB: u32 = 2151175434;
+pub const AUTOFS_IOC_READY: u32 = 37728;
+pub const BTRFS_IOC_SEND: u32 = 1078498342;
+pub const VIDIOC_G_EXT_CTRLS: u32 = 3223344711;
+pub const JSIOCSBTNMAP: u32 = 1140877875;
+pub const PPPIOCSFLAGS: u32 = 1074033753;
+pub const NVRAM_INIT: u32 = 28736;
+pub const RFKILL_IOCTL_NOINPUT: u32 = 20993;
+pub const BTRFS_IOC_BALANCE: u32 = 1342215180;
+pub const FS_IOC_GETFSMAP: u32 = 3233830971;
+pub const IPMICTL_GET_MY_CHANNEL_LUN_CMD: u32 = 2147772699;
+pub const STP_POLICY_ID_GET: u32 = 2148541697;
+pub const PPSETFLAGS: u32 = 1074032795;
+pub const CEC_ADAP_S_PHYS_ADDR: u32 = 1073897730;
+pub const ATMTCP_CREATE: u32 = 24974;
+pub const IPMI_BMC_IOCTL_FORCE_ABORT: u32 = 45314;
+pub const PPPIOCGXASYNCMAP: u32 = 2149610576;
+pub const VHOST_SET_VRING_CALL: u32 = 1074310945;
+pub const LIRC_GET_FEATURES: u32 = 2147772672;
+pub const GSMIOC_DISABLE_NET: u32 = 18179;
+pub const AUTOFS_IOC_CATATONIC: u32 = 37730;
+pub const NBD_DO_IT: u32 = 43779;
+pub const LIRC_SET_REC_CARRIER_RANGE: u32 = 1074030879;
+pub const IPMICTL_GET_MY_CHANNEL_ADDRESS_CMD: u32 = 2147772697;
+pub const EVIOCSCLOCKID: u32 = 1074021792;
+pub const USBDEVFS_FREE_STREAMS: u32 = 2148029725;
+pub const FSI_SCOM_RESET: u32 = 1074033411;
+pub const PMU_IOC_GRAB_BACKLIGHT: u32 = 2148024838;
+pub const VIDIOC_SUBDEV_S_FMT: u32 = 3227014661;
+pub const FDDEFPRM: u32 = 1075839555;
+pub const TEE_IOC_INVOKE: u32 = 2148574211;
+pub const USBDEVFS_BULK: u32 = 3222820098;
+pub const SCIF_VWRITETO: u32 = 3223876365;
+pub const SONYPI_IOCSBRT: u32 = 1073837568;
+pub const BTRFS_IOC_FILE_EXTENT_SAME: u32 = 3222836278;
+pub const RTC_PIE_ON: u32 = 28677;
+pub const BTRFS_IOC_SCAN_DEV: u32 = 1342215172;
+pub const PPPIOCXFERUNIT: u32 = 29774;
+pub const WDIOC_GETTIMEOUT: u32 = 2147768071;
+pub const BTRFS_IOC_SET_RECEIVED_SUBVOL: u32 = 3234370597;
+pub const DFL_FPGA_PORT_ERR_SET_IRQ: u32 = 1074312774;
+pub const FBIO_WAITFORVSYNC: u32 = 1074021920;
+pub const RTC_PIE_OFF: u32 = 28678;
+pub const EVIOCGRAB: u32 = 1074021776;
+pub const PMU_IOC_SET_BACKLIGHT: u32 = 1074283010;
+pub const EVIOCGREP: u32 = 2148025603;
+pub const PERF_EVENT_IOC_MODIFY_ATTRIBUTES: u32 = 1074275339;
+pub const UFFDIO_CONTINUE: u32 = 3223366151;
+pub const VDUSE_GET_API_VERSION: u32 = 2148040960;
+pub const RTC_RD_TIME: u32 = 2149871625;
+pub const FDMSGOFF: u32 = 582;
+pub const IPMICTL_REGISTER_FOR_CMD_CHANS: u32 = 2148296988;
+pub const CAPI_GET_ERRCODE: u32 = 2147631905;
+pub const PCITEST_SET_IRQTYPE: u32 = 1074024456;
+pub const VIDIOC_SUBDEV_S_EDID: u32 = 3223868969;
+pub const MATROXFB_SET_OUTPUT_MODE: u32 = 1074294522;
+pub const RIO_DEV_ADD: u32 = 1075866903;
+pub const VIDIOC_ENUM_FREQ_BANDS: u32 = 3225441893;
+pub const FBIO_RADEON_SET_MIRROR: u32 = 1074282500;
+pub const PCITEST_GET_IRQTYPE: u32 = 20489;
+pub const JSIOCGVERSION: u32 = 2147772929;
+pub const SONYPI_IOCSBLUE: u32 = 1073837577;
+pub const SNAPSHOT_PREF_IMAGE_SIZE: u32 = 13074;
+pub const F2FS_IOC_GET_FEATURES: u32 = 2147808524;
+pub const SCIF_REG: u32 = 3223876360;
+pub const NILFS_IOCTL_CLEAN_SEGMENTS: u32 = 1081634440;
+pub const FW_CDEV_IOC_INITIATE_BUS_RESET: u32 = 1074012933;
+pub const RIO_WAIT_FOR_ASYNC: u32 = 1074294038;
+pub const VHOST_SET_VRING_NUM: u32 = 1074310928;
+pub const AUTOFS_DEV_IOCTL_PROTOVER: u32 = 3222836082;
+pub const RIO_FREE_DMA: u32 = 1074294036;
+pub const MGSL_IOCRXENABLE: u32 = 27909;
+pub const IOCTL_VM_SOCKETS_GET_LOCAL_CID: u32 = 1977;
+pub const IPMICTL_SET_TIMING_PARMS_CMD: u32 = 2148034838;
+pub const PPPIOCGL2TPSTATS: u32 = 2152231990;
+pub const PERF_EVENT_IOC_PERIOD: u32 = 1074275332;
+pub const PTP_PIN_SETFUNC2: u32 = 1080048912;
+pub const CHIOEXCHANGE: u32 = 1075602178;
+pub const NILFS_IOCTL_GET_SUINFO: u32 = 2149084804;
+pub const CEC_DQEVENT: u32 = 3226493191;
+pub const UI_SET_SWBIT: u32 = 1074025837;
+pub const VHOST_VDPA_SET_CONFIG: u32 = 1074311028;
+pub const TUNSETIFF: u32 = 1074025674;
+pub const CHIOPOSITION: u32 = 1074553603;
+pub const IPMICTL_SET_MAINTENANCE_MODE_CMD: u32 = 1074030879;
+pub const BTRFS_IOC_DEFAULT_SUBVOL: u32 = 1074304019;
+pub const RIO_UNMAP_OUTBOUND: u32 = 1076391184;
+pub const CAPI_CLR_FLAGS: u32 = 2147762981;
+pub const FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE_ONCE: u32 = 1075323663;
+pub const MATROXFB_GET_OUTPUT_CONNECTION: u32 = 2148036344;
+pub const EVIOCSMASK: u32 = 1074808211;
+pub const BTRFS_IOC_FORGET_DEV: u32 = 1342215173;
+pub const CXL_MEM_QUERY_COMMANDS: u32 = 2148060673;
+pub const CEC_S_MODE: u32 = 1074028809;
+pub const MGSL_IOCSIF: u32 = 27914;
+pub const SWITCHTEC_IOCTL_PFF_TO_PORT: u32 = 3222034244;
+pub const PPSETMODE: u32 = 1074032768;
+pub const VFIO_DEVICE_SET_IRQS: u32 = 15214;
+pub const VIDIOC_PREPARE_BUF: u32 = 3227014749;
+pub const CEC_ADAP_G_CONNECTOR_INFO: u32 = 2151964938;
+pub const IOC_OPAL_WRITE_SHADOW_MBR: u32 = 1092645098;
+pub const VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: u32 = 3225441867;
+pub const UDMABUF_CREATE: u32 = 1075344706;
+pub const SONET_CLRDIAG: u32 = 3221512467;
+pub const PHN_SET_REG: u32 = 1074294785;
+pub const RNDADDTOENTCNT: u32 = 1074024961;
+pub const VBG_IOCTL_CHECK_BALLOON: u32 = 3223344657;
+pub const VIDIOC_OMAP3ISP_STAT_REQ: u32 = 3223869126;
+pub const PPS_FETCH: u32 = 3221778596;
+pub const RTC_AIE_OFF: u32 = 28674;
+pub const VFIO_GROUP_SET_CONTAINER: u32 = 15208;
+pub const FW_CDEV_IOC_RECEIVE_PHY_PACKETS: u32 = 1074275094;
+pub const VFIO_IOMMU_SPAPR_TCE_REMOVE: u32 = 15224;
+pub const VFIO_IOMMU_GET_INFO: u32 = 15216;
+pub const DM_DEV_SUSPEND: u32 = 3241737478;
+pub const F2FS_IOC_GET_COMPRESS_OPTION: u32 = 2147677461;
+pub const FW_CDEV_IOC_STOP_ISO: u32 = 1074012939;
+pub const GPIO_V2_GET_LINEINFO_IOCTL: u32 = 3238048773;
+pub const ATMMPC_CTRL: u32 = 25048;
+pub const PPPIOCSXASYNCMAP: u32 = 1075868751;
+pub const CHIOGSTATUS: u32 = 1074815752;
+pub const FW_CDEV_IOC_ALLOCATE_ISO_RESOURCE: u32 = 3222807309;
+pub const RIO_MPORT_MAINT_PORT_IDX_GET: u32 = 2147773699;
+pub const CAPI_SET_FLAGS: u32 = 2147762980;
+pub const VFIO_GROUP_GET_DEVICE_FD: u32 = 15210;
+pub const VHOST_SET_MEM_TABLE: u32 = 1074310915;
+pub const MATROXFB_SET_OUTPUT_CONNECTION: u32 = 1074294520;
+pub const DFL_FPGA_PORT_GET_REGION_INFO: u32 = 46658;
+pub const VHOST_GET_FEATURES: u32 = 2148052736;
+pub const LIRC_GET_REC_RESOLUTION: u32 = 2147772679;
+pub const PACKET_CTRL_CMD: u32 = 3222820865;
+pub const LIRC_SET_TRANSMITTER_MASK: u32 = 1074030871;
+pub const BTRFS_IOC_ADD_DEV: u32 = 1342215178;
+pub const JSIOCGCORR: u32 = 2149870114;
+pub const VIDIOC_G_FMT: u32 = 3234878980;
+pub const RTC_EPOCH_SET: u32 = 1074294798;
+pub const CAPI_GET_PROFILE: u32 = 3225436937;
+pub const ATM_GETLOOP: u32 = 1074815314;
+pub const SCIF_LISTEN: u32 = 1074033410;
+pub const NBD_CLEAR_QUE: u32 = 43781;
+pub const F2FS_IOC_MOVE_RANGE: u32 = 3223385353;
+pub const LIRC_GET_LENGTH: u32 = 2147772687;
+pub const I8K_SET_FAN: u32 = 3221776775;
+pub const FDSETMAXERRS: u32 = 1075053132;
+pub const VIDIOC_SUBDEV_QUERYCAP: u32 = 2151699968;
+pub const SNAPSHOT_SET_SWAP_AREA: u32 = 1074541325;
+pub const LIRC_GET_REC_TIMEOUT: u32 = 2147772708;
+pub const EVIOCRMFF: u32 = 1074021761;
+pub const GPIO_GET_LINEEVENT_IOCTL: u32 = 3224417284;
+pub const PPRDATA: u32 = 2147577989;
+pub const RIO_MPORT_GET_PROPERTIES: u32 = 2150657284;
+pub const TUNSETVNETHDRSZ: u32 = 1074025688;
+pub const GPIO_GET_LINEINFO_IOCTL: u32 = 3225990146;
+pub const GSMIOC_GETCONF: u32 = 2152482560;
+pub const LIRC_GET_SEND_MODE: u32 = 2147772673;
+pub const PPPIOCSACTIVE: u32 = 1074820166;
+pub const SIOCGSTAMPNS_NEW: u32 = 2148567303;
+pub const IPMICTL_RECEIVE_MSG: u32 = 3224398092;
+pub const LIRC_SET_SEND_DUTY_CYCLE: u32 = 1074030869;
+pub const UI_END_FF_ERASE: u32 = 1074550219;
+pub const SWITCHTEC_IOCTL_FLASH_PART_INFO: u32 = 3222296385;
+pub const FW_CDEV_IOC_SEND_PHY_PACKET: u32 = 3222807317;
+pub const NBD_SET_FLAGS: u32 = 43786;
+pub const VFIO_DEVICE_GET_REGION_INFO: u32 = 15212;
+pub const REISERFS_IOC_UNPACK: u32 = 1074318593;
+pub const FW_CDEV_IOC_REMOVE_DESCRIPTOR: u32 = 1074012935;
+pub const RIO_SET_EVENT_MASK: u32 = 1074031885;
+pub const SNAPSHOT_ALLOC_SWAP_PAGE: u32 = 2148021012;
+pub const VDUSE_VQ_INJECT_IRQ: u32 = 1074037015;
+pub const I2OPASSTHRU: u32 = 2148559116;
+pub const IOC_OPAL_SET_PW: u32 = 1109422304;
+pub const FSI_SCOM_READ: u32 = 3223352065;
+pub const VHOST_VDPA_GET_DEVICE_ID: u32 = 2147790704;
+pub const VIDIOC_QBUF: u32 = 3227014671;
+pub const VIDIOC_S_TUNER: u32 = 1079268894;
+pub const TUNGETVNETHDRSZ: u32 = 2147767511;
+pub const CAPI_NCCI_GETUNIT: u32 = 2147762983;
+pub const DFL_FPGA_PORT_UINT_GET_IRQ_NUM: u32 = 2147792455;
+pub const VIDIOC_OMAP3ISP_STAT_EN: u32 = 3221771975;
+pub const GPIO_V2_LINE_SET_CONFIG_IOCTL: u32 = 3239097357;
+pub const TEE_IOC_VERSION: u32 = 2148312064;
+pub const VIDIOC_LOG_STATUS: u32 = 22086;
+pub const IPMICTL_SEND_COMMAND_SETTIME: u32 = 2150656277;
+pub const VHOST_SET_LOG_FD: u32 = 1074048775;
+pub const SCIF_SEND: u32 = 3222827782;
+pub const VIDIOC_SUBDEV_G_FMT: u32 = 3227014660;
+pub const NS_ADJBUFLEV: u32 = 24931;
+pub const VIDIOC_DBG_S_REGISTER: u32 = 1077433935;
+pub const NILFS_IOCTL_RESIZE: u32 = 1074294411;
+pub const PHN_GETREG: u32 = 3221778437;
+pub const I2OSWDL: u32 = 3224398085;
+pub const VBG_IOCTL_VMMDEV_REQUEST_BIG: u32 = 22019;
+pub const JSIOCGBUTTONS: u32 = 2147576338;
+pub const VFIO_IOMMU_ENABLE: u32 = 15219;
+pub const DM_DEV_RENAME: u32 = 3241737477;
+pub const MEDIA_IOC_SETUP_LINK: u32 = 3224665091;
+pub const VIDIOC_ENUMOUTPUT: u32 = 3225966128;
+pub const STP_POLICY_ID_SET: u32 = 3222283520;
+pub const VHOST_VDPA_SET_CONFIG_CALL: u32 = 1074048887;
+pub const VIDIOC_SUBDEV_G_CROP: u32 = 3224917563;
+pub const VIDIOC_S_CROP: u32 = 1075074620;
+pub const WDIOC_GETTEMP: u32 = 2147768067;
+pub const IOC_OPAL_ADD_USR_TO_LR: u32 = 1092120804;
+pub const UI_SET_LEDBIT: u32 = 1074025833;
+pub const NBD_SET_SOCK: u32 = 43776;
+pub const BTRFS_IOC_SNAP_DESTROY_V2: u32 = 1342215231;
+pub const HIDIOCGCOLLECTIONINFO: u32 = 3222292497;
+pub const I2OSWUL: u32 = 3224398086;
+pub const IOCTL_MEI_NOTIFY_GET: u32 = 2147764227;
+pub const FDFMTTRK: u32 = 1074528840;
+pub const MMTIMER_GETBITS: u32 = 27908;
+pub const VIDIOC_ENUMSTD: u32 = 3225966105;
+pub const VHOST_GET_VRING_BASE: u32 = 3221794578;
+pub const VFIO_DEVICE_IOEVENTFD: u32 = 15220;
+pub const ATMARP_SETENTRY: u32 = 25059;
+pub const CCISS_REVALIDVOLS: u32 = 16906;
+pub const MGSL_IOCLOOPTXDONE: u32 = 27913;
+pub const RTC_VL_READ: u32 = 2147774483;
+pub const ND_IOCTL_ARS_STATUS: u32 = 3224391171;
+pub const RIO_DEV_DEL: u32 = 1075866904;
+pub const VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES: u32 = 3223606797;
+pub const VIDIOC_SUBDEV_DV_TIMINGS_CAP: u32 = 3230684772;
+pub const SONYPI_IOCSFAN: u32 = 1073837579;
+pub const SPIOCSTYPE: u32 = 1074295041;
+pub const IPMICTL_REGISTER_FOR_CMD: u32 = 2147641614;
+pub const I8K_GET_FAN: u32 = 3221776774;
+pub const TUNGETVNETBE: u32 = 2147767519;
+pub const AUTOFS_DEV_IOCTL_FAIL: u32 = 3222836087;
+pub const UI_END_FF_UPLOAD: u32 = 1080579529;
+pub const TOSH_SMM: u32 = 3222828176;
+pub const SONYPI_IOCGBAT2REM: u32 = 2147644933;
+pub const F2FS_IOC_GET_COMPRESS_BLOCKS: u32 = 2148070673;
+pub const PPPIOCSNPMODE: u32 = 1074295883;
+pub const USBDEVFS_CONTROL: u32 = 3222820096;
+pub const HIDIOCGUSAGE: u32 = 3222816779;
+pub const TUNSETTXFILTER: u32 = 1074025681;
+pub const TUNGETVNETLE: u32 = 2147767517;
+pub const VIDIOC_ENUM_DV_TIMINGS: u32 = 3230946914;
+pub const BTRFS_IOC_INO_PATHS: u32 = 3224933411;
+pub const MGSL_IOCGXSYNC: u32 = 27924;
+pub const HIDIOCGFIELDINFO: u32 = 3224913930;
+pub const VIDIOC_SUBDEV_G_STD: u32 = 2148029975;
+pub const I2OVALIDATE: u32 = 2147772680;
+pub const VIDIOC_TRY_ENCODER_CMD: u32 = 3223869006;
+pub const NILFS_IOCTL_GET_CPINFO: u32 = 2149084802;
+pub const VIDIOC_G_FREQUENCY: u32 = 3224131128;
+pub const VFAT_IOCTL_READDIR_SHORT: u32 = 2184212994;
+pub const ND_IOCTL_GET_CONFIG_DATA: u32 = 3222031877;
+pub const F2FS_IOC_RESERVE_COMPRESS_BLOCKS: u32 = 2148070675;
+pub const FDGETDRVSTAT: u32 = 2152727058;
+pub const SYNC_IOC_MERGE: u32 = 3224387075;
+pub const VIDIOC_S_DV_TIMINGS: u32 = 3229898327;
+pub const PPPIOCBRIDGECHAN: u32 = 1074033717;
+pub const LIRC_SET_SEND_MODE: u32 = 1074030865;
+pub const RIO_ENABLE_PORTWRITE_RANGE: u32 = 1074818315;
+pub const ATM_GETTYPE: u32 = 1074815364;
+pub const PHN_GETREGS: u32 = 3223875591;
+pub const FDSETEMSGTRESH: u32 = 586;
+pub const NILFS_IOCTL_GET_VINFO: u32 = 3222826630;
+pub const MGSL_IOCWAITEVENT: u32 = 3221515528;
+pub const CAPI_INSTALLED: u32 = 2147631906;
+pub const EVIOCGMASK: u32 = 2148550034;
+pub const BTRFS_IOC_SUBVOL_GETFLAGS: u32 = 2148045849;
+pub const FSL_HV_IOCTL_PARTITION_GET_STATUS: u32 = 3222056706;
+pub const MEDIA_IOC_ENUM_ENTITIES: u32 = 3238034433;
+pub const GSMIOC_GETFIRST: u32 = 2147763972;
+pub const FW_CDEV_IOC_FLUSH_ISO: u32 = 1074012952;
+pub const VIDIOC_DBG_G_CHIP_INFO: u32 = 3234354790;
+pub const F2FS_IOC_RELEASE_VOLATILE_WRITE: u32 = 62724;
+pub const CAPI_GET_SERIAL: u32 = 3221504776;
+pub const FDSETDRVPRM: u32 = 1082131088;
+pub const IOC_OPAL_SAVE: u32 = 1092120796;
+pub const VIDIOC_G_DV_TIMINGS: u32 = 3229898328;
+pub const TUNSETIFINDEX: u32 = 1074025690;
+pub const CCISS_SETINTINFO: u32 = 1074283011;
+pub const CM_IOSDBGLVL: u32 = 1074291706;
+pub const RTC_VL_CLR: u32 = 28692;
+pub const VIDIOC_REQBUFS: u32 = 3222558216;
+pub const USBDEVFS_REAPURBNDELAY32: u32 = 1074025741;
+pub const TEE_IOC_SHM_REGISTER: u32 = 3222840329;
+pub const USBDEVFS_SETCONFIGURATION: u32 = 2147767557;
+pub const CCISS_GETNODENAME: u32 = 2148549124;
+pub const VIDIOC_SUBDEV_S_FRAME_INTERVAL: u32 = 3224393238;
+pub const VIDIOC_ENUM_FRAMESIZES: u32 = 3224131146;
+pub const VFIO_DEVICE_PCI_HOT_RESET: u32 = 15217;
+pub const FW_CDEV_IOC_SEND_BROADCAST_REQUEST: u32 = 1076372242;
+pub const LPSETTIMEOUT_NEW: u32 = 1074791951;
+pub const RIO_CM_MPORT_GET_LIST: u32 = 3221512971;
+pub const FW_CDEV_IOC_QUEUE_ISO: u32 = 3222807305;
+pub const FDRAWCMD: u32 = 600;
+pub const SCIF_UNREG: u32 = 3222303497;
+pub const PPPIOCGIDLE64: u32 = 2148561983;
+pub const USBDEVFS_RELEASEINTERFACE: u32 = 2147767568;
+pub const VIDIOC_CROPCAP: u32 = 3224131130;
+pub const DFL_FPGA_PORT_GET_INFO: u32 = 46657;
+pub const PHN_SET_REGS: u32 = 1074294787;
+pub const ATMLEC_DATA: u32 = 25041;
+pub const PPPOEIOCDFWD: u32 = 45313;
+pub const VIDIOC_S_SELECTION: u32 = 3225441887;
+pub const SNAPSHOT_FREE_SWAP_PAGES: u32 = 13065;
+pub const BTRFS_IOC_LOGICAL_INO: u32 = 3224933412;
+pub const VIDIOC_S_CTRL: u32 = 3221771804;
+pub const ZATM_SETPOOL: u32 = 1074815331;
+pub const MTIOCPOS: u32 = 2148035843;
+pub const PMU_IOC_SLEEP: u32 = 16896;
+pub const AUTOFS_DEV_IOCTL_PROTOSUBVER: u32 = 3222836083;
+pub const VBG_IOCTL_CHANGE_FILTER_MASK: u32 = 3223344652;
+pub const NILFS_IOCTL_GET_SUSTAT: u32 = 2150657669;
+pub const VIDIOC_QUERYCAP: u32 = 2154321408;
+pub const HPET_INFO: u32 = 2149083139;
+pub const VIDIOC_AM437X_CCDC_CFG: u32 = 1074288321;
+pub const DM_LIST_DEVICES: u32 = 3241737474;
+pub const TUNSETOWNER: u32 = 1074025676;
+pub const VBG_IOCTL_CHANGE_GUEST_CAPABILITIES: u32 = 3223344654;
+pub const RNDADDENTROPY: u32 = 1074287107;
+pub const USBDEVFS_RESET: u32 = 21780;
+pub const BTRFS_IOC_SUBVOL_CREATE: u32 = 1342215182;
+pub const USBDEVFS_FORBID_SUSPEND: u32 = 21793;
+pub const FDGETDRVTYP: u32 = 2148532751;
+pub const PPWCONTROL: u32 = 1073836164;
+pub const VIDIOC_ENUM_FRAMEINTERVALS: u32 = 3224655435;
+pub const KCOV_DISABLE: u32 = 25445;
+pub const IOC_OPAL_ACTIVATE_LSP: u32 = 1092120799;
+pub const VHOST_VDPA_GET_IOVA_RANGE: u32 = 2148577144;
+pub const PPPIOCSPASS: u32 = 1074820167;
+pub const RIO_CM_CHAN_CONNECT: u32 = 1074291464;
+pub const I2OSWDEL: u32 = 3224398087;
+pub const FS_IOC_SET_ENCRYPTION_POLICY: u32 = 2148296211;
+pub const IOC_OPAL_MBR_DONE: u32 = 1091596521;
+pub const PPPIOCSMAXCID: u32 = 1074033745;
+pub const PPSETPHASE: u32 = 1074032788;
+pub const VHOST_VDPA_SET_VRING_ENABLE: u32 = 1074311029;
+pub const USBDEVFS_GET_SPEED: u32 = 21791;
+pub const SONET_GETFRAMING: u32 = 2147770646;
+pub const VIDIOC_QUERYBUF: u32 = 3227014665;
+pub const VIDIOC_S_EDID: u32 = 3223868969;
+pub const BTRFS_IOC_QGROUP_ASSIGN: u32 = 1075352617;
+pub const PPS_GETCAP: u32 = 2148036771;
+pub const SNAPSHOT_PLATFORM_SUPPORT: u32 = 13071;
+pub const LIRC_SET_REC_TIMEOUT_REPORTS: u32 = 1074030873;
+pub const SCIF_GET_NODEIDS: u32 = 3222827790;
+pub const NBD_DISCONNECT: u32 = 43784;
+pub const VIDIOC_SUBDEV_G_FRAME_INTERVAL: u32 = 3224393237;
+pub const VFIO_IOMMU_DISABLE: u32 = 15220;
+pub const SNAPSHOT_CREATE_IMAGE: u32 = 1074017041;
+pub const SNAPSHOT_POWER_OFF: u32 = 13072;
+pub const APM_IOC_STANDBY: u32 = 16641;
+pub const PPPIOCGUNIT: u32 = 2147775574;
+pub const AUTOFS_IOC_EXPIRE_MULTI: u32 = 1074041702;
+pub const SCIF_BIND: u32 = 3221779201;
+pub const IOC_WATCH_QUEUE_SET_SIZE: u32 = 22368;
+pub const NILFS_IOCTL_CHANGE_CPMODE: u32 = 1074818688;
+pub const IOC_OPAL_LOCK_UNLOCK: u32 = 1092120797;
+pub const F2FS_IOC_SET_PIN_FILE: u32 = 1074066701;
+pub const PPPIOCGRASYNCMAP: u32 = 2147775573;
+pub const MMTIMER_MMAPAVAIL: u32 = 27910;
+pub const I2OPASSTHRU32: u32 = 2148034828;
+pub const DFL_FPGA_FME_PORT_RELEASE: u32 = 1074050689;
+pub const VIDIOC_SUBDEV_QUERY_DV_TIMINGS: u32 = 2156156515;
+pub const UI_SET_SNDBIT: u32 = 1074025834;
+pub const VIDIOC_G_AUDOUT: u32 = 2150913585;
+pub const RTC_PLL_SET: u32 = 1075867666;
+pub const VIDIOC_ENUMAUDIO: u32 = 3224655425;
+pub const AUTOFS_DEV_IOCTL_TIMEOUT: u32 = 3222836090;
+pub const VBG_IOCTL_DRIVER_VERSION_INFO: u32 = 3224131072;
+pub const VHOST_SCSI_GET_EVENTS_MISSED: u32 = 1074048836;
+pub const VHOST_SET_VRING_ADDR: u32 = 1076408081;
+pub const VDUSE_CREATE_DEV: u32 = 1095794946;
+pub const FDFLUSH: u32 = 587;
+pub const VBG_IOCTL_WAIT_FOR_EVENTS: u32 = 3223344650;
+pub const DFL_FPGA_FME_ERR_SET_IRQ: u32 = 1074312836;
+pub const F2FS_IOC_GET_PIN_FILE: u32 = 2147808526;
+pub const SCIF_CONNECT: u32 = 3221779203;
+pub const BLKREPORTZONE: u32 = 3222278786;
+pub const AUTOFS_IOC_ASKUMOUNT: u32 = 2147783536;
+pub const ATM_ADDPARTY: u32 = 1074815476;
+pub const FDSETPRM: u32 = 1075839554;
+pub const ATM_GETSTATZ: u32 = 1074815313;
+pub const ISST_IF_MSR_COMMAND: u32 = 3221814788;
+pub const BTRFS_IOC_GET_SUBVOL_INFO: u32 = 2180551740;
+pub const VIDIOC_UNSUBSCRIBE_EVENT: u32 = 1075861083;
+pub const SEV_ISSUE_CMD: u32 = 3222295296;
+pub const GPIOHANDLE_SET_LINE_VALUES_IOCTL: u32 = 3225465865;
+pub const PCITEST_COPY: u32 = 1074286598;
+pub const IPMICTL_GET_MY_ADDRESS_CMD: u32 = 2147772690;
+pub const CHIOGPICKER: u32 = 2147771140;
+pub const CAPI_NCCI_OPENCOUNT: u32 = 2147762982;
+pub const CXL_MEM_SEND_COMMAND: u32 = 3224423938;
+pub const PERF_EVENT_IOC_SET_FILTER: u32 = 1074275334;
+pub const IOC_OPAL_REVERT_TPR: u32 = 1091072226;
+pub const CHIOGVPARAMS: u32 = 2154849043;
+pub const PTP_PEROUT_REQUEST: u32 = 1077427459;
+pub const FSI_SCOM_CHECK: u32 = 2147775232;
+pub const RTC_IRQP_READ: u32 = 2148036619;
+pub const RIO_MPORT_MAINT_READ_LOCAL: u32 = 2149084421;
+pub const HIDIOCGRDESCSIZE: u32 = 2147764225;
+pub const UI_GET_VERSION: u32 = 2147767597;
+pub const NILFS_IOCTL_GET_CPSTAT: u32 = 2149084803;
+pub const CCISS_GETBUSTYPES: u32 = 2147762695;
+pub const VFIO_IOMMU_SPAPR_TCE_CREATE: u32 = 15223;
+pub const VIDIOC_EXPBUF: u32 = 3225441808;
+pub const UI_SET_RELBIT: u32 = 1074025830;
+pub const VFIO_SET_IOMMU: u32 = 15206;
+pub const VIDIOC_S_MODULATOR: u32 = 1078220343;
+pub const TUNGETFILTER: u32 = 2148553947;
+pub const MEYEIOC_SYNC: u32 = 3221518019;
+pub const CCISS_SETNODENAME: u32 = 1074807301;
+pub const FBIO_GETCONTROL2: u32 = 2148025993;
+pub const TUNSETDEBUG: u32 = 1074025673;
+pub const DM_DEV_REMOVE: u32 = 3241737476;
+pub const HIDIOCSUSAGES: u32 = 1344030740;
+pub const FS_IOC_ADD_ENCRYPTION_KEY: u32 = 3226494487;
+pub const FBIOGET_VBLANK: u32 = 2149598738;
+pub const ATM_GETSTAT: u32 = 1074815312;
+pub const VIDIOC_G_JPEGCOMP: u32 = 2156680765;
+pub const TUNATTACHFILTER: u32 = 1074812117;
+pub const UI_SET_ABSBIT: u32 = 1074025831;
+pub const DFL_FPGA_PORT_ERR_GET_IRQ_NUM: u32 = 2147792453;
+pub const USBDEVFS_REAPURB32: u32 = 1074025740;
+pub const BTRFS_IOC_TRANS_END: u32 = 37895;
+pub const CAPI_REGISTER: u32 = 1074545409;
+pub const F2FS_IOC_COMPRESS_FILE: u32 = 62744;
+pub const USBDEVFS_DISCARDURB: u32 = 21771;
+pub const HE_GET_REG: u32 = 1074815328;
+pub const ATM_SETLOOP: u32 = 1074815315;
+pub const ATMSIGD_CTRL: u32 = 25072;
+pub const CIOC_KERNEL_VERSION: u32 = 3221775114;
+pub const BTRFS_IOC_CLONE_RANGE: u32 = 1075876877;
+pub const SNAPSHOT_UNFREEZE: u32 = 13058;
+pub const F2FS_IOC_START_VOLATILE_WRITE: u32 = 62723;
+pub const PMU_IOC_HAS_ADB: u32 = 2148024836;
+pub const I2OGETIOPS: u32 = 2149607680;
+pub const VIDIOC_S_FBUF: u32 = 1076909579;
+pub const PPRCONTROL: u32 = 2147577987;
+pub const CHIOSPICKER: u32 = 1074029317;
+pub const VFIO_IOMMU_SPAPR_REGISTER_MEMORY: u32 = 15221;
+pub const TUNGETSNDBUF: u32 = 2147767507;
+pub const GSMIOC_SETCONF: u32 = 1078740737;
+pub const IOC_PR_PREEMPT: u32 = 1075343563;
+pub const KCOV_INIT_TRACE: u32 = 2148033281;
+pub const SONYPI_IOCGBAT1CAP: u32 = 2147644930;
+pub const SWITCHTEC_IOCTL_FLASH_INFO: u32 = 2148554560;
+pub const MTIOCTOP: u32 = 1074294017;
+pub const VHOST_VDPA_SET_STATUS: u32 = 1073852274;
+pub const VHOST_SCSI_SET_EVENTS_MISSED: u32 = 1074048835;
+pub const VFIO_IOMMU_DIRTY_PAGES: u32 = 15221;
+pub const BTRFS_IOC_SCRUB_PROGRESS: u32 = 3288372253;
+pub const PPPIOCGMRU: u32 = 2147775571;
+pub const BTRFS_IOC_DEV_REPLACE: u32 = 3391657013;
+pub const PPPIOCGFLAGS: u32 = 2147775578;
+pub const NILFS_IOCTL_SET_SUINFO: u32 = 1075342989;
+pub const FW_CDEV_IOC_GET_CYCLE_TIMER2: u32 = 3222807316;
+pub const ATM_DELLECSADDR: u32 = 1074815375;
+pub const FW_CDEV_IOC_GET_SPEED: u32 = 8977;
+pub const PPPIOCGIDLE32: u32 = 2148037695;
+pub const VFIO_DEVICE_RESET: u32 = 15215;
+pub const GPIO_GET_LINEINFO_UNWATCH_IOCTL: u32 = 3221533708;
+pub const WDIOC_GETSTATUS: u32 = 2147768065;
+pub const BTRFS_IOC_SET_FEATURES: u32 = 1076925497;
+pub const IOCTL_MEI_CONNECT_CLIENT: u32 = 3222292481;
+pub const VIDIOC_OMAP3ISP_AEWB_CFG: u32 = 3223344835;
+pub const PCITEST_READ: u32 = 1074286597;
+pub const VFIO_GROUP_GET_STATUS: u32 = 15207;
+pub const MATROXFB_GET_ALL_OUTPUTS: u32 = 2148036347;
+pub const USBDEVFS_CLEAR_HALT: u32 = 2147767573;
+pub const VIDIOC_DECODER_CMD: u32 = 3225966176;
+pub const VIDIOC_G_AUDIO: u32 = 2150913569;
+pub const CCISS_RESCANDISK: u32 = 16912;
+pub const RIO_DISABLE_PORTWRITE_RANGE: u32 = 1074818316;
+pub const IOC_OPAL_SECURE_ERASE_LR: u32 = 1091596519;
+pub const USBDEVFS_REAPURB: u32 = 1074287884;
+pub const DFL_FPGA_CHECK_EXTENSION: u32 = 46593;
+pub const AUTOFS_IOC_PROTOVER: u32 = 2147783523;
+pub const FSL_HV_IOCTL_MEMCPY: u32 = 3223891717;
+pub const BTRFS_IOC_GET_FEATURES: u32 = 2149094457;
+pub const PCITEST_MSIX: u32 = 1074024455;
+pub const BTRFS_IOC_DEFRAG_RANGE: u32 = 1076925456;
+pub const UI_BEGIN_FF_ERASE: u32 = 3222033866;
+pub const DM_GET_TARGET_VERSION: u32 = 3241737489;
+pub const PPPIOCGIDLE: u32 = 2148561983;
+pub const NVRAM_SETCKS: u32 = 28737;
+pub const WDIOC_GETSUPPORT: u32 = 2150127360;
+pub const GSMIOC_ENABLE_NET: u32 = 1077167874;
+pub const GPIO_GET_CHIPINFO_IOCTL: u32 = 2151986177;
+pub const NE_ADD_VCPU: u32 = 3221532193;
+pub const EVIOCSKEYCODE_V2: u32 = 1076380932;
+pub const PTP_SYS_OFFSET_EXTENDED2: u32 = 3300932882;
+pub const SCIF_FENCE_WAIT: u32 = 3221517072;
+pub const RIO_TRANSFER: u32 = 3222826261;
+pub const FSL_HV_IOCTL_DOORBELL: u32 = 3221794566;
+pub const RIO_MPORT_MAINT_WRITE_LOCAL: u32 = 1075342598;
+pub const I2OEVTREG: u32 = 1074555146;
+pub const I2OPARMGET: u32 = 3223873796;
+pub const EVIOCGID: u32 = 2148025602;
+pub const BTRFS_IOC_QGROUP_CREATE: u32 = 1074828330;
+pub const AUTOFS_DEV_IOCTL_SETPIPEFD: u32 = 3222836088;
+pub const VIDIOC_S_PARM: u32 = 3234616854;
+pub const TUNSETSTEERINGEBPF: u32 = 2147767520;
+pub const ATM_GETNAMES: u32 = 1074815363;
+pub const VIDIOC_QUERYMENU: u32 = 3224131109;
+pub const DFL_FPGA_PORT_DMA_UNMAP: u32 = 46660;
+pub const I2OLCTGET: u32 = 3222825218;
+pub const FS_IOC_GET_ENCRYPTION_PWSALT: u32 = 1074816532;
+pub const NS_SETBUFLEV: u32 = 1074815330;
+pub const BLKCLOSEZONE: u32 = 1074795143;
+pub const SONET_GETFRSENSE: u32 = 2147901719;
+pub const UI_SET_EVBIT: u32 = 1074025828;
+pub const DM_LIST_VERSIONS: u32 = 3241737485;
+pub const HIDIOCGSTRING: u32 = 2164541444;
+pub const PPPIOCATTCHAN: u32 = 1074033720;
+pub const VDUSE_DEV_SET_CONFIG: u32 = 1074299154;
+pub const TUNGETFEATURES: u32 = 2147767503;
+pub const VFIO_GROUP_UNSET_CONTAINER: u32 = 15209;
+pub const IPMICTL_SET_MY_ADDRESS_CMD: u32 = 2147772689;
+pub const CCISS_REGNEWDISK: u32 = 1074020877;
+pub const VIDIOC_QUERY_DV_TIMINGS: u32 = 2156156515;
+pub const PHN_SETREGS: u32 = 1076391944;
+pub const FAT_IOCTL_GET_ATTRIBUTES: u32 = 2147774992;
+pub const FSL_MC_SEND_MC_COMMAND: u32 = 3225440992;
+pub const TUNGETIFF: u32 = 2147767506;
+pub const PTP_CLOCK_GETCAPS2: u32 = 2152742154;
+pub const BTRFS_IOC_RESIZE: u32 = 1342215171;
+pub const VHOST_SET_VRING_ENDIAN: u32 = 1074310931;
+pub const PPS_KC_BIND: u32 = 1074294949;
+pub const F2FS_IOC_WRITE_CHECKPOINT: u32 = 62727;
+pub const UI_SET_FFBIT: u32 = 1074025835;
+pub const IPMICTL_GET_MY_LUN_CMD: u32 = 2147772692;
+pub const CEC_ADAP_G_PHYS_ADDR: u32 = 2147639553;
+pub const CEC_G_MODE: u32 = 2147770632;
+pub const USBDEVFS_RESETEP: u32 = 2147767555;
+pub const MEDIA_REQUEST_IOC_QUEUE: u32 = 31872;
+pub const USBDEVFS_ALLOC_STREAMS: u32 = 2148029724;
+pub const MGSL_IOCSXCTRL: u32 = 27925;
+pub const MEDIA_IOC_G_TOPOLOGY: u32 = 3225975812;
+pub const PPPIOCUNBRIDGECHAN: u32 = 29748;
+pub const F2FS_IOC_COMMIT_ATOMIC_WRITE: u32 = 62722;
+pub const ISST_IF_GET_PLATFORM_INFO: u32 = 2148072960;
+pub const SCIF_FENCE_MARK: u32 = 3222303503;
+pub const USBDEVFS_RELEASE_PORT: u32 = 2147767577;
+pub const VFIO_CHECK_EXTENSION: u32 = 15205;
+pub const BTRFS_IOC_QGROUP_LIMIT: u32 = 2150667307;
+pub const FAT_IOCTL_GET_VOLUME_ID: u32 = 2147774995;
+pub const UI_SET_PHYS: u32 = 1074287980;
+pub const FDWERRORGET: u32 = 2150105623;
+pub const VIDIOC_SUBDEV_G_EDID: u32 = 3223868968;
+pub const MGSL_IOCGSTATS: u32 = 27911;
+pub const RPROC_SET_SHUTDOWN_ON_RELEASE: u32 = 1074050817;
+pub const SIOCGSTAMP_NEW: u32 = 2148567302;
+pub const RTC_WKALM_RD: u32 = 2150133776;
+pub const PHN_GET_REG: u32 = 3221778432;
+pub const DELL_WMI_SMBIOS_CMD: u32 = 3224655616;
+pub const PHN_NOT_OH: u32 = 28676;
+pub const PPGETMODES: u32 = 2147774615;
+pub const CHIOGPARAMS: u32 = 2148819718;
+pub const VFIO_DEVICE_GET_GFX_DMABUF: u32 = 15219;
+pub const VHOST_SET_VRING_BUSYLOOP_TIMEOUT: u32 = 1074310947;
+pub const VIDIOC_SUBDEV_G_SELECTION: u32 = 3225441853;
+pub const BTRFS_IOC_RM_DEV_V2: u32 = 1342215226;
+pub const MGSL_IOCWAITGPIO: u32 = 3222301970;
+pub const PMU_IOC_CAN_SLEEP: u32 = 2148024837;
+pub const KCOV_ENABLE: u32 = 25444;
+pub const BTRFS_IOC_CLONE: u32 = 1074041865;
+pub const F2FS_IOC_DEFRAGMENT: u32 = 3222336776;
+pub const FW_CDEV_IOC_DEALLOCATE_ISO_RESOURCE: u32 = 1074012942;
+pub const AGPIOC_ALLOCATE: u32 = 3221766406;
+pub const NE_SET_USER_MEMORY_REGION: u32 = 1075359267;
+pub const MGSL_IOCTXABORT: u32 = 27910;
+pub const MGSL_IOCSGPIO: u32 = 1074818320;
+pub const LIRC_SET_REC_CARRIER: u32 = 1074030868;
+pub const F2FS_IOC_FLUSH_DEVICE: u32 = 1074328842;
+pub const SNAPSHOT_ATOMIC_RESTORE: u32 = 13060;
+pub const RTC_UIE_OFF: u32 = 28676;
+pub const BT_BMC_IOCTL_SMS_ATN: u32 = 45312;
+pub const NVME_IOCTL_ID: u32 = 20032;
+pub const NE_START_ENCLAVE: u32 = 3222318628;
+pub const VIDIOC_STREAMON: u32 = 1074026002;
+pub const FDPOLLDRVSTAT: u32 = 2152727059;
+pub const AUTOFS_DEV_IOCTL_READY: u32 = 3222836086;
+pub const VIDIOC_ENUMAUDOUT: u32 = 3224655426;
+pub const VIDIOC_SUBDEV_S_STD: u32 = 1074288152;
+pub const WDIOC_GETTIMELEFT: u32 = 2147768074;
+pub const ATM_GETLINKRATE: u32 = 1074815361;
+pub const RTC_WKALM_SET: u32 = 1076391951;
+pub const VHOST_GET_BACKEND_FEATURES: u32 = 2148052774;
+pub const ATMARP_ENCAP: u32 = 25061;
+pub const CAPI_GET_FLAGS: u32 = 2147762979;
+pub const IPMICTL_SET_MY_CHANNEL_ADDRESS_CMD: u32 = 2147772696;
+pub const DFL_FPGA_FME_PORT_ASSIGN: u32 = 1074050690;
+pub const NS_GET_OWNER_UID: u32 = 46852;
+pub const VIDIOC_OVERLAY: u32 = 1074025998;
+pub const BTRFS_IOC_WAIT_SYNC: u32 = 1074304022;
+pub const GPIOHANDLE_SET_CONFIG_IOCTL: u32 = 3226776586;
+pub const VHOST_GET_VRING_ENDIAN: u32 = 1074310932;
+pub const ATM_GETADDR: u32 = 1074815366;
+pub const PHN_GET_REGS: u32 = 3221778434;
+pub const AUTOFS_DEV_IOCTL_REQUESTER: u32 = 3222836091;
+pub const AUTOFS_DEV_IOCTL_EXPIRE: u32 = 3222836092;
+pub const SNAPSHOT_S2RAM: u32 = 13067;
+pub const JSIOCSAXMAP: u32 = 1077963313;
+pub const F2FS_IOC_SET_COMPRESS_OPTION: u32 = 1073935638;
+pub const VBG_IOCTL_HGCM_DISCONNECT: u32 = 3223082501;
+pub const SCIF_FENCE_SIGNAL: u32 = 3223876369;
+pub const VFIO_DEVICE_GET_PCI_HOT_RESET_INFO: u32 = 15216;
+pub const VIDIOC_SUBDEV_ENUM_MBUS_CODE: u32 = 3224393218;
+pub const MMTIMER_GETOFFSET: u32 = 27904;
+pub const RIO_CM_CHAN_LISTEN: u32 = 1073898246;
+pub const ATM_SETSC: u32 = 1074029041;
+pub const F2FS_IOC_SHUTDOWN: u32 = 2147768445;
+pub const NVME_IOCTL_RESCAN: u32 = 20038;
+pub const BLKOPENZONE: u32 = 1074795142;
+pub const DM_VERSION: u32 = 3241737472;
+pub const CEC_TRANSMIT: u32 = 3224920325;
+pub const FS_IOC_GET_ENCRYPTION_POLICY_EX: u32 = 3221841430;
+pub const SIOCMKCLIP: u32 = 25056;
+pub const IPMI_BMC_IOCTL_CLEAR_SMS_ATN: u32 = 45313;
+pub const HIDIOCGVERSION: u32 = 2147764225;
+pub const VIDIOC_S_INPUT: u32 = 3221509671;
+pub const VIDIOC_G_CROP: u32 = 3222558267;
+pub const LIRC_SET_WIDEBAND_RECEIVER: u32 = 1074030883;
+pub const EVIOCGEFFECTS: u32 = 2147763588;
+pub const UVCIOC_CTRL_QUERY: u32 = 3222304033;
+pub const IOC_OPAL_GENERIC_TABLE_RW: u32 = 1094217963;
+pub const FS_IOC_READ_VERITY_METADATA: u32 = 3223873159;
+pub const ND_IOCTL_SET_CONFIG_DATA: u32 = 3221769734;
+pub const USBDEVFS_GETDRIVER: u32 = 1090802952;
+pub const IDT77105_GETSTAT: u32 = 1074815282;
+pub const HIDIOCINITREPORT: u32 = 18437;
+pub const VFIO_DEVICE_GET_INFO: u32 = 15211;
+pub const RIO_CM_CHAN_RECEIVE: u32 = 3222299402;
+pub const RNDGETENTCNT: u32 = 2147766784;
+pub const PPPIOCNEWUNIT: u32 = 3221517374;
+pub const BTRFS_IOC_INO_LOOKUP: u32 = 3489698834;
+pub const FDRESET: u32 = 596;
+pub const IOC_PR_REGISTER: u32 = 1075343560;
+pub const HIDIOCSREPORT: u32 = 1074546696;
+pub const TEE_IOC_OPEN_SESSION: u32 = 2148574210;
+pub const TEE_IOC_SUPPL_RECV: u32 = 2148574214;
+pub const BTRFS_IOC_BALANCE_CTL: u32 = 1074041889;
+pub const GPIO_GET_LINEINFO_WATCH_IOCTL: u32 = 3225990155;
+pub const HIDIOCGRAWINFO: u32 = 2148026371;
+pub const PPPIOCSCOMPRESS: u32 = 1074820173;
+pub const USBDEVFS_CONNECTINFO: u32 = 1074287889;
+pub const BLKRESETZONE: u32 = 1074795139;
+pub const CHIOINITELEM: u32 = 25361;
+pub const NILFS_IOCTL_SET_ALLOC_RANGE: u32 = 1074818700;
+pub const AUTOFS_DEV_IOCTL_CATATONIC: u32 = 3222836089;
+pub const RIO_MPORT_MAINT_HDID_SET: u32 = 1073900801;
+pub const PPGETPHASE: u32 = 2147774617;
+pub const USBDEVFS_DISCONNECT_CLAIM: u32 = 2164806939;
+pub const FDMSGON: u32 = 581;
+pub const VIDIOC_G_SLICED_VBI_CAP: u32 = 3228849733;
+pub const BTRFS_IOC_BALANCE_V2: u32 = 3288372256;
+pub const MEDIA_REQUEST_IOC_REINIT: u32 = 31873;
+pub const IOC_OPAL_ERASE_LR: u32 = 1091596518;
+pub const FDFMTBEG: u32 = 583;
+pub const RNDRESEEDCRNG: u32 = 20999;
+pub const ISST_IF_GET_PHY_ID: u32 = 3221814785;
+pub const TUNSETNOCSUM: u32 = 1074025672;
+pub const SONET_GETSTAT: u32 = 2149867792;
+pub const TFD_IOC_SET_TICKS: u32 = 1074287616;
+pub const PPDATADIR: u32 = 1074032784;
+pub const IOC_OPAL_ENABLE_DISABLE_MBR: u32 = 1091596517;
+pub const GPIO_V2_GET_LINE_IOCTL: u32 = 3260068871;
+pub const RIO_CM_CHAN_SEND: u32 = 1074815753;
+pub const PPWCTLONIRQ: u32 = 1073836178;
+pub const SONYPI_IOCGBRT: u32 = 2147579392;
+pub const IOC_PR_RELEASE: u32 = 1074819274;
+pub const PPCLRIRQ: u32 = 2147774611;
+pub const IPMICTL_SET_MY_CHANNEL_LUN_CMD: u32 = 2147772698;
+pub const MGSL_IOCSXSYNC: u32 = 27923;
+pub const HPET_IE_OFF: u32 = 26626;
+pub const IOC_OPAL_ACTIVATE_USR: u32 = 1091596513;
+pub const SONET_SETFRAMING: u32 = 1074028821;
+pub const PERF_EVENT_IOC_PAUSE_OUTPUT: u32 = 1074013193;
+pub const BTRFS_IOC_LOGICAL_INO_V2: u32 = 3224933435;
+pub const VBG_IOCTL_HGCM_CONNECT: u32 = 3231471108;
+pub const BLKFINISHZONE: u32 = 1074795144;
+pub const EVIOCREVOKE: u32 = 1074021777;
+pub const VFIO_DEVICE_FEATURE: u32 = 15221;
+pub const CCISS_GETPCIINFO: u32 = 2148024833;
+pub const ISST_IF_MBOX_COMMAND: u32 = 3221814787;
+pub const SCIF_ACCEPTREQ: u32 = 3222303492;
+pub const PERF_EVENT_IOC_QUERY_BPF: u32 = 3221758986;
+pub const VIDIOC_STREAMOFF: u32 = 1074026003;
+pub const VDUSE_DESTROY_DEV: u32 = 1090552067;
+pub const FDGETFDCSTAT: u32 = 2150105621;
+pub const CM_IOCGATR: u32 = 3221775105;
+pub const VIDIOC_S_PRIORITY: u32 = 1074026052;
+pub const SNAPSHOT_FREEZE: u32 = 13057;
+pub const VIDIOC_ENUMINPUT: u32 = 3226490394;
+pub const ZATM_GETPOOLZ: u32 = 1074815330;
+pub const RIO_DISABLE_DOORBELL_RANGE: u32 = 1074294026;
+pub const GPIO_V2_GET_LINEINFO_WATCH_IOCTL: u32 = 3238048774;
+pub const VIDIOC_G_STD: u32 = 2148029975;
+pub const USBDEVFS_ALLOW_SUSPEND: u32 = 21794;
+pub const SONET_GETSTATZ: u32 = 2149867793;
+pub const SCIF_ACCEPTREG: u32 = 3221779205;
+pub const VIDIOC_ENCODER_CMD: u32 = 3223869005;
+pub const PPPIOCSRASYNCMAP: u32 = 1074033748;
+pub const IOCTL_MEI_NOTIFY_SET: u32 = 1074022402;
+pub const BTRFS_IOC_QUOTA_RESCAN_STATUS: u32 = 2151715885;
+pub const F2FS_IOC_GARBAGE_COLLECT: u32 = 1074066694;
+pub const ATMLEC_CTRL: u32 = 25040;
+pub const MATROXFB_GET_AVAILABLE_OUTPUTS: u32 = 2148036345;
+pub const DM_DEV_CREATE: u32 = 3241737475;
+pub const VHOST_VDPA_GET_VRING_NUM: u32 = 2147659638;
+pub const VIDIOC_G_CTRL: u32 = 3221771803;
+pub const NBD_CLEAR_SOCK: u32 = 43780;
+pub const VFIO_DEVICE_QUERY_GFX_PLANE: u32 = 15218;
+pub const WDIOC_KEEPALIVE: u32 = 2147768069;
+pub const NVME_IOCTL_SUBSYS_RESET: u32 = 20037;
+pub const PTP_EXTTS_REQUEST2: u32 = 1074806027;
+pub const PCITEST_BAR: u32 = 20481;
+pub const MGSL_IOCGGPIO: u32 = 2148560145;
+pub const EVIOCSREP: u32 = 1074283779;
+pub const VFIO_DEVICE_GET_IRQ_INFO: u32 = 15213;
+pub const HPET_DPI: u32 = 26629;
+pub const VDUSE_VQ_SETUP_KICKFD: u32 = 1074299158;
+pub const ND_IOCTL_CALL: u32 = 3225439754;
+pub const HIDIOCGDEVINFO: u32 = 2149337091;
+pub const DM_TABLE_DEPS: u32 = 3241737483;
+pub const BTRFS_IOC_DEV_INFO: u32 = 3489698846;
+pub const VDUSE_IOTLB_GET_FD: u32 = 3223355664;
+pub const FW_CDEV_IOC_GET_INFO: u32 = 3223855872;
+pub const VIDIOC_G_PRIORITY: u32 = 2147767875;
+pub const ATM_NEWBACKENDIF: u32 = 1073897971;
+pub const VIDIOC_S_EXT_CTRLS: u32 = 3223344712;
+pub const VIDIOC_SUBDEV_ENUM_DV_TIMINGS: u32 = 3230946914;
+pub const VIDIOC_OMAP3ISP_CCDC_CFG: u32 = 3224917697;
+pub const VIDIOC_S_HW_FREQ_SEEK: u32 = 1076909650;
+pub const DM_TABLE_LOAD: u32 = 3241737481;
+pub const F2FS_IOC_START_ATOMIC_WRITE: u32 = 62721;
+pub const VIDIOC_G_OUTPUT: u32 = 2147767854;
+pub const ATM_DROPPARTY: u32 = 1074029045;
+pub const CHIOGELEM: u32 = 1080845072;
+pub const BTRFS_IOC_GET_SUPPORTED_FEATURES: u32 = 2152240185;
+pub const EVIOCSKEYCODE: u32 = 1074283780;
+pub const NE_GET_IMAGE_LOAD_INFO: u32 = 3222318626;
+pub const TUNSETLINK: u32 = 1074025677;
+pub const FW_CDEV_IOC_ADD_DESCRIPTOR: u32 = 3222807302;
+pub const BTRFS_IOC_SCRUB_CANCEL: u32 = 37916;
+pub const PPS_SETPARAMS: u32 = 1074294946;
+pub const IOC_OPAL_LR_SETUP: u32 = 1093169379;
+pub const FW_CDEV_IOC_DEALLOCATE: u32 = 1074012931;
+pub const WDIOC_SETTIMEOUT: u32 = 3221509894;
+pub const IOC_WATCH_QUEUE_SET_FILTER: u32 = 22369;
+pub const CAPI_GET_MANUFACTURER: u32 = 3221504774;
+pub const VFIO_IOMMU_SPAPR_UNREGISTER_MEMORY: u32 = 15222;
+pub const ASPEED_P2A_CTRL_IOCTL_SET_WINDOW: u32 = 1074836224;
+pub const VIDIOC_G_EDID: u32 = 3223868968;
+pub const F2FS_IOC_GARBAGE_COLLECT_RANGE: u32 = 1075377419;
+pub const RIO_MAP_INBOUND: u32 = 3223874833;
+pub const IOC_OPAL_TAKE_OWNERSHIP: u32 = 1091072222;
+pub const USBDEVFS_CLAIM_PORT: u32 = 2147767576;
+pub const VIDIOC_S_AUDIO: u32 = 1077171746;
+pub const FS_IOC_GET_ENCRYPTION_NONCE: u32 = 2148558363;
+pub const FW_CDEV_IOC_SEND_STREAM_PACKET: u32 = 1076372243;
+pub const BTRFS_IOC_SNAP_DESTROY: u32 = 1342215183;
+pub const SNAPSHOT_FREE: u32 = 13061;
+pub const I8K_GET_SPEED: u32 = 3221776773;
+pub const HIDIOCGREPORT: u32 = 1074546695;
+pub const HPET_EPI: u32 = 26628;
+pub const JSIOCSCORR: u32 = 1076128289;
+pub const IOC_PR_PREEMPT_ABORT: u32 = 1075343564;
+pub const RIO_MAP_OUTBOUND: u32 = 3223874831;
+pub const ATM_SETESI: u32 = 1074815372;
+pub const FW_CDEV_IOC_START_ISO: u32 = 1074799370;
+pub const ATM_DELADDR: u32 = 1074815369;
+pub const PPFCONTROL: u32 = 1073901710;
+pub const SONYPI_IOCGFAN: u32 = 2147579402;
+pub const RTC_IRQP_SET: u32 = 1074294796;
+pub const PCITEST_WRITE: u32 = 1074286596;
+pub const PPCLAIM: u32 = 28811;
+pub const VIDIOC_S_JPEGCOMP: u32 = 1082938942;
+pub const IPMICTL_UNREGISTER_FOR_CMD: u32 = 2147641615;
+pub const VHOST_SET_FEATURES: u32 = 1074310912;
+pub const TOSHIBA_ACPI_SCI: u32 = 3222828177;
+pub const VIDIOC_DQBUF: u32 = 3227014673;
+pub const BTRFS_IOC_BALANCE_PROGRESS: u32 = 2214630434;
+pub const BTRFS_IOC_SUBVOL_SETFLAGS: u32 = 1074304026;
+pub const ATMLEC_MCAST: u32 = 25042;
+pub const MMTIMER_GETFREQ: u32 = 2148035842;
+pub const VIDIOC_G_SELECTION: u32 = 3225441886;
+pub const RTC_ALM_SET: u32 = 1076129799;
+pub const PPPOEIOCSFWD: u32 = 1074311424;
+pub const IPMICTL_GET_MAINTENANCE_MODE_CMD: u32 = 2147772702;
+pub const FS_IOC_ENABLE_VERITY: u32 = 1082156677;
+pub const NILFS_IOCTL_GET_BDESCS: u32 = 3222826631;
+pub const FDFMTEND: u32 = 585;
+pub const DMA_BUF_SET_NAME: u32 = 1074291201;
+pub const UI_BEGIN_FF_UPLOAD: u32 = 3228063176;
+pub const RTC_UIE_ON: u32 = 28675;
+pub const PPRELEASE: u32 = 28812;
+pub const VFIO_IOMMU_UNMAP_DMA: u32 = 15218;
+pub const VIDIOC_OMAP3ISP_PRV_CFG: u32 = 3228587714;
+pub const GPIO_GET_LINEHANDLE_IOCTL: u32 = 3245126659;
+pub const VFAT_IOCTL_READDIR_BOTH: u32 = 2184212993;
+pub const NVME_IOCTL_ADMIN_CMD: u32 = 3225964097;
+pub const VHOST_SET_VRING_KICK: u32 = 1074310944;
+pub const BTRFS_IOC_SUBVOL_CREATE_V2: u32 = 1342215192;
+pub const BTRFS_IOC_SNAP_CREATE: u32 = 1342215169;
+pub const SONYPI_IOCGBAT2CAP: u32 = 2147644932;
+pub const PPNEGOT: u32 = 1074032785;
+pub const NBD_PRINT_DEBUG: u32 = 43782;
+pub const BTRFS_IOC_INO_LOOKUP_USER: u32 = 3489698878;
+pub const BTRFS_IOC_GET_SUBVOL_ROOTREF: u32 = 3489698877;
+pub const FS_IOC_REMOVE_ENCRYPTION_KEY_ALL_USERS: u32 = 3225445913;
+pub const BTRFS_IOC_FS_INFO: u32 = 2214630431;
+pub const VIDIOC_ENUM_FMT: u32 = 3225441794;
+pub const VIDIOC_G_INPUT: u32 = 2147767846;
+pub const VTPM_PROXY_IOC_NEW_DEV: u32 = 3222577408;
+pub const DFL_FPGA_FME_ERR_GET_IRQ_NUM: u32 = 2147792515;
+pub const ND_IOCTL_DIMM_FLAGS: u32 = 3221769731;
+pub const BTRFS_IOC_QUOTA_RESCAN: u32 = 1077974060;
+pub const MMTIMER_GETCOUNTER: u32 = 2148035849;
+pub const MATROXFB_GET_OUTPUT_MODE: u32 = 3221778170;
+pub const BTRFS_IOC_QUOTA_RESCAN_WAIT: u32 = 37934;
+pub const RIO_CM_CHAN_BIND: u32 = 1074291461;
+pub const HIDIOCGRDESC: u32 = 2416199682;
+pub const MGSL_IOCGIF: u32 = 27915;
+pub const VIDIOC_S_OUTPUT: u32 = 3221509679;
+pub const HIDIOCGREPORTINFO: u32 = 3222030345;
+pub const WDIOC_GETBOOTSTATUS: u32 = 2147768066;
+pub const VDUSE_VQ_GET_INFO: u32 = 3224404245;
+pub const ACRN_IOCTL_ASSIGN_PCIDEV: u32 = 1076142677;
+pub const BLKGETDISKSEQ: u32 = 2148012672;
+pub const ACRN_IOCTL_PM_GET_CPU_STATE: u32 = 3221791328;
+pub const ACRN_IOCTL_DESTROY_VM: u32 = 41489;
+pub const ACRN_IOCTL_SET_PTDEV_INTR: u32 = 1075094099;
+pub const ACRN_IOCTL_CREATE_IOREQ_CLIENT: u32 = 41522;
+pub const ACRN_IOCTL_IRQFD: u32 = 1075356273;
+pub const ACRN_IOCTL_CREATE_VM: u32 = 3224412688;
+pub const ACRN_IOCTL_INJECT_MSI: u32 = 1074831907;
+pub const ACRN_IOCTL_ATTACH_IOREQ_CLIENT: u32 = 41523;
+pub const ACRN_IOCTL_RESET_PTDEV_INTR: u32 = 1075094100;
+pub const ACRN_IOCTL_NOTIFY_REQUEST_FINISH: u32 = 1074307633;
+pub const ACRN_IOCTL_SET_IRQLINE: u32 = 1074307621;
+pub const ACRN_IOCTL_START_VM: u32 = 41490;
+pub const ACRN_IOCTL_SET_VCPU_REGS: u32 = 1093181974;
+pub const ACRN_IOCTL_SET_MEMSEG: u32 = 1075880513;
+pub const ACRN_IOCTL_PAUSE_VM: u32 = 41491;
+pub const ACRN_IOCTL_CLEAR_VM_IOREQ: u32 = 41525;
+pub const ACRN_IOCTL_UNSET_MEMSEG: u32 = 1075880514;
+pub const ACRN_IOCTL_IOEVENTFD: u32 = 1075880560;
+pub const ACRN_IOCTL_DEASSIGN_PCIDEV: u32 = 1076142678;
+pub const ACRN_IOCTL_RESET_VM: u32 = 41493;
+pub const ACRN_IOCTL_DESTROY_IOREQ_CLIENT: u32 = 41524;
+pub const ACRN_IOCTL_VM_INTR_MONITOR: u32 = 1074307620;

.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/loongarch64/landlock.rs

@@ -0,0 +1,104 @@
+/* automatically generated by rust-bindgen 0.72.1 */
+
+pub type __s8 = crate::ctypes::c_schar;
+pub type __u8 = crate::ctypes::c_uchar;
+pub type __s16 = crate::ctypes::c_short;
+pub type __u16 = crate::ctypes::c_ushort;
+pub type __s32 = crate::ctypes::c_int;
+pub type __u32 = crate::ctypes::c_uint;
+pub type __s64 = crate::ctypes::c_longlong;
+pub type __u64 = crate::ctypes::c_ulonglong;
+pub type __kernel_key_t = crate::ctypes::c_int;
+pub type __kernel_mqd_t = crate::ctypes::c_int;
+pub type __kernel_long_t = crate::ctypes::c_long;
+pub type __kernel_ulong_t = crate::ctypes::c_ulong;
+pub type __kernel_ino_t = __kernel_ulong_t;
+pub type __kernel_mode_t = crate::ctypes::c_uint;
+pub type __kernel_pid_t = crate::ctypes::c_int;
+pub type __kernel_ipc_pid_t = crate::ctypes::c_int;
+pub type __kernel_uid_t = crate::ctypes::c_uint;
+pub type __kernel_gid_t = crate::ctypes::c_uint;
+pub type __kernel_suseconds_t = __kernel_long_t;
+pub type __kernel_daddr_t = crate::ctypes::c_int;
+pub type __kernel_uid32_t = crate::ctypes::c_uint;
+pub type __kernel_gid32_t = crate::ctypes::c_uint;
+pub type __kernel_old_uid_t = __kernel_uid_t;
+pub type __kernel_old_gid_t = __kernel_gid_t;
+pub type __kernel_old_dev_t = crate::ctypes::c_uint;
+pub type __kernel_size_t = __kernel_ulong_t;
+pub type __kernel_ssize_t = __kernel_long_t;
+pub type __kernel_ptrdiff_t = __kernel_long_t;
+pub type __kernel_off_t = __kernel_long_t;
+pub type __kernel_loff_t = crate::ctypes::c_longlong;
+pub type __kernel_old_time_t = __kernel_long_t;
+pub type __kernel_time_t = __kernel_long_t;
+pub type __kernel_time64_t = crate::ctypes::c_longlong;
+pub type __kernel_clock_t = __kernel_long_t;
+pub type __kernel_timer_t = crate::ctypes::c_int;
+pub type __kernel_clockid_t = crate::ctypes::c_int;
+pub type __kernel_caddr_t = *mut crate::ctypes::c_char;
+pub type __kernel_uid16_t = crate::ctypes::c_ushort;
+pub type __kernel_gid16_t = crate::ctypes::c_ushort;
+pub type __s128 = i128;
+pub type __u128 = u128;
+pub type __le16 = __u16;
+pub type __be16 = __u16;
+pub type __le32 = __u32;
+pub type __be32 = __u32;
+pub type __le64 = __u64;
+pub type __be64 = __u64;
+pub type __sum16 = __u16;
+pub type __wsum = __u32;
+pub type __poll_t = crate::ctypes::c_uint;
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_ruleset_attr {
+pub handled_access_fs: __u64,
+pub handled_access_net: __u64,
+pub scoped: __u64,
+}
+#[repr(C, packed)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_path_beneath_attr {
+pub allowed_access: __u64,
+pub parent_fd: __s32,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone)]
+pub struct landlock_net_port_attr {
+pub allowed_access: __u64,
+pub port: __u64,
+}
+pub const __BITS_PER_LONG_LONG: u32 = 64;
+pub const LANDLOCK_CREATE_RULESET_VERSION: u32 = 1;
+pub const LANDLOCK_CREATE_RULESET_ERRATA: u32 = 2;
+pub const LANDLOCK_RESTRICT_SELF_LOG_SAME_EXEC_OFF: u32 = 1;
+pub const LANDLOCK_RESTRICT_SELF_LOG_NEW_EXEC_ON: u32 = 2;
+pub const LANDLOCK_RESTRICT_SELF_LOG_SUBDOMAINS_OFF: u32 = 4;
+pub const LANDLOCK_ACCESS_FS_EXECUTE: u32 = 1;
+pub const LANDLOCK_ACCESS_FS_WRITE_FILE: u32 = 2;
+pub const LANDLOCK_ACCESS_FS_READ_FILE: u32 = 4;
+pub const LANDLOCK_ACCESS_FS_READ_DIR: u32 = 8;
+pub const LANDLOCK_ACCESS_FS_REMOVE_DIR: u32 = 16;
+pub const LANDLOCK_ACCESS_FS_REMOVE_FILE: u32 = 32;
+pub const LANDLOCK_ACCESS_FS_MAKE_CHAR: u32 = 64;
+pub const LANDLOCK_ACCESS_FS_MAKE_DIR: u32 = 128;
+pub const LANDLOCK_ACCESS_FS_MAKE_REG: u32 = 256;
+pub const LANDLOCK_ACCESS_FS_MAKE_SOCK: u32 = 512;
+pub const LANDLOCK_ACCESS_FS_MAKE_FIFO: u32 = 1024;
+pub const LANDLOCK_ACCESS_FS_MAKE_BLOCK: u32 = 2048;
+pub const LANDLOCK_ACCESS_FS_MAKE_SYM: u32 = 4096;
+pub const LANDLOCK_ACCESS_FS_REFER: u32 = 8192;
+pub const LANDLOCK_ACCESS_FS_TRUNCATE: u32 = 16384;
+pub const LANDLOCK_ACCESS_FS_IOCTL_DEV: u32 = 32768;
+pub const LANDLOCK_ACCESS_NET_BIND_TCP: u32 = 1;
+pub const LANDLOCK_ACCESS_NET_CONNECT_TCP: u32 = 2;
+pub const LANDLOCK_SCOPE_ABSTRACT_UNIX_SOCKET: u32 = 1;
+pub const LANDLOCK_SCOPE_SIGNAL: u32 = 2;
+#[repr(u32)]
+#[non_exhaustive]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum landlock_rule_type {
+LANDLOCK_RULE_PATH_BENEATH = 1,
+LANDLOCK_RULE_NET_PORT = 2,
+}