Full Code of youki-dev/youki for AI

gitextract_z_kcjarp/

├── .cargo/
│   └── config.toml
├── .codecov.yml
├── .devcontainer/
│   ├── Dockerfile
│   ├── devcontainer-lock.json
│   └── devcontainer.json
├── .git-blame-ignore-revs
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── BUG_REPORT.yml
│   │   ├── FEATURE_REQ.yml
│   │   └── config.yml
│   ├── dependabot.yml
│   ├── grcov.yml
│   ├── pull_request_template.md
│   ├── release.yml
│   └── workflows/
│       ├── basic.yml
│       ├── benchmark_execution_time.yml
│       ├── dependabot_auto.yaml
│       ├── docs.yaml
│       ├── e2e.yaml
│       ├── integration_tests_validation.yaml
│       ├── label.yaml
│       ├── podman_tests.yaml
│       ├── release.yaml
│       ├── runc_integration_tests.yaml
│       ├── selinux.yaml
│       ├── tagpr.yaml
│       └── update_version_config.yaml
├── .gitignore
├── .gitmodules
├── .tagpr
├── .typos.toml
├── CHANGELOG.md
├── CODE-OF-CONDUCT.md
├── Cargo.toml
├── Cross.toml
├── LICENSE
├── MigrationGuide.md
├── README.md
├── SECURITY.md
├── Vagrantfile
├── crates/
│   ├── .gitignore
│   ├── libcgroups/
│   │   ├── .gitignore
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── examples/
│   │   │   ├── bpf.rs
│   │   │   ├── rules.json
│   │   │   └── systemd_io.rs
│   │   └── src/
│   │       ├── common.rs
│   │       ├── lib.rs
│   │       ├── stats.rs
│   │       ├── stub/
│   │       │   ├── systemd/
│   │       │   │   ├── manager.rs
│   │       │   │   └── mod.rs
│   │       │   ├── v1/
│   │       │   │   ├── manager.rs
│   │       │   │   └── mod.rs
│   │       │   └── v2/
│   │       │       ├── manager.rs
│   │       │       └── mod.rs
│   │       ├── systemd/
│   │       │   ├── controller.rs
│   │       │   ├── controller_type.rs
│   │       │   ├── cpu.rs
│   │       │   ├── cpuset.rs
│   │       │   ├── dbus_native/
│   │       │   │   ├── client.rs
│   │       │   │   ├── dbus.rs
│   │       │   │   ├── message.rs
│   │       │   │   ├── mod.rs
│   │       │   │   ├── proxy.rs
│   │       │   │   ├── serialize.rs
│   │       │   │   └── utils.rs
│   │       │   ├── io.rs
│   │       │   ├── manager.rs
│   │       │   ├── memory.rs
│   │       │   ├── mod.rs
│   │       │   ├── pids.rs
│   │       │   └── unified.rs
│   │       ├── test.rs
│   │       ├── test_manager.rs
│   │       ├── v1/
│   │       │   ├── blkio.rs
│   │       │   ├── controller.rs
│   │       │   ├── controller_type.rs
│   │       │   ├── cpu.rs
│   │       │   ├── cpuacct.rs
│   │       │   ├── cpuset.rs
│   │       │   ├── devices.rs
│   │       │   ├── freezer.rs
│   │       │   ├── hugetlb.rs
│   │       │   ├── manager.rs
│   │       │   ├── memory.rs
│   │       │   ├── mod.rs
│   │       │   ├── network_classifier.rs
│   │       │   ├── network_priority.rs
│   │       │   ├── perf_event.rs
│   │       │   ├── pids.rs
│   │       │   └── util.rs
│   │       └── v2/
│   │           ├── controller.rs
│   │           ├── controller_type.rs
│   │           ├── cpu.rs
│   │           ├── cpuset.rs
│   │           ├── devices/
│   │           │   ├── bpf.rs
│   │           │   ├── controller.rs
│   │           │   ├── emulator.rs
│   │           │   ├── mocks.rs
│   │           │   ├── mod.rs
│   │           │   └── program.rs
│   │           ├── freezer.rs
│   │           ├── hugetlb.rs
│   │           ├── io.rs
│   │           ├── manager.rs
│   │           ├── memory.rs
│   │           ├── mod.rs
│   │           ├── pids.rs
│   │           ├── unified.rs
│   │           └── util.rs
│   ├── libcontainer/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── src/
│   │   │   ├── apparmor.rs
│   │   │   ├── capabilities.rs
│   │   │   ├── channel.rs
│   │   │   ├── config.rs
│   │   │   ├── container/
│   │   │   │   ├── builder.rs
│   │   │   │   ├── builder_impl.rs
│   │   │   │   ├── container.rs
│   │   │   │   ├── container_checkpoint.rs
│   │   │   │   ├── container_criu.rs
│   │   │   │   ├── container_delete.rs
│   │   │   │   ├── container_events.rs
│   │   │   │   ├── container_kill.rs
│   │   │   │   ├── container_pause.rs
│   │   │   │   ├── container_resume.rs
│   │   │   │   ├── container_start.rs
│   │   │   │   ├── init_builder.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── state.rs
│   │   │   │   └── tenant_builder.rs
│   │   │   ├── error.rs
│   │   │   ├── hooks.rs
│   │   │   ├── lib.rs
│   │   │   ├── namespaces.rs
│   │   │   ├── network/
│   │   │   │   ├── address.rs
│   │   │   │   ├── cidr.rs
│   │   │   │   ├── client.rs
│   │   │   │   ├── fake.rs
│   │   │   │   ├── link.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── network_device.rs
│   │   │   │   ├── traits.rs
│   │   │   │   └── wrapper.rs
│   │   │   ├── notify_socket.rs
│   │   │   ├── process/
│   │   │   │   ├── args.rs
│   │   │   │   ├── channel.rs
│   │   │   │   ├── container_intermediate_process.rs
│   │   │   │   ├── container_main_process.rs
│   │   │   │   ├── cpu_affinity.rs
│   │   │   │   ├── fork.rs
│   │   │   │   ├── init/
│   │   │   │   │   ├── context.rs
│   │   │   │   │   ├── error.rs
│   │   │   │   │   ├── mod.rs
│   │   │   │   │   └── process.rs
│   │   │   │   ├── intel_rdt.rs
│   │   │   │   ├── memory_policy.rs
│   │   │   │   ├── message.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── seccomp_listener.rs
│   │   │   ├── rootfs/
│   │   │   │   ├── device.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── mount.rs
│   │   │   │   ├── rootfs.rs
│   │   │   │   ├── symlink.rs
│   │   │   │   └── utils.rs
│   │   │   ├── seccomp/
│   │   │   │   ├── fixture/
│   │   │   │   │   └── config.json
│   │   │   │   └── mod.rs
│   │   │   ├── signal.rs
│   │   │   ├── syscall/
│   │   │   │   ├── linux.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── syscall.rs
│   │   │   │   └── test.rs
│   │   │   ├── test_utils.rs
│   │   │   ├── tty.rs
│   │   │   ├── user_ns.rs
│   │   │   ├── utils.rs
│   │   │   └── workload/
│   │   │       ├── default.rs
│   │   │       └── mod.rs
│   │   └── tests/
│   │       └── as_sibling.rs
│   ├── liboci-cli/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── checkpoint.rs
│   │       ├── create.rs
│   │       ├── delete.rs
│   │       ├── events.rs
│   │       ├── exec.rs
│   │       ├── features.rs
│   │       ├── info.rs
│   │       ├── kill.rs
│   │       ├── lib.rs
│   │       ├── list.rs
│   │       ├── pause.rs
│   │       ├── ps.rs
│   │       ├── resume.rs
│   │       ├── run.rs
│   │       ├── spec.rs
│   │       ├── start.rs
│   │       ├── state.rs
│   │       └── update.rs
│   └── youki/
│       ├── Cargo.toml
│       ├── build.rs
│       └── src/
│           ├── commands/
│           │   ├── checkpoint.rs
│           │   ├── completion.rs
│           │   ├── create.rs
│           │   ├── delete.rs
│           │   ├── events.rs
│           │   ├── exec.rs
│           │   ├── features.rs
│           │   ├── info.rs
│           │   ├── kill.rs
│           │   ├── list.rs
│           │   ├── mod.rs
│           │   ├── pause.rs
│           │   ├── ps.rs
│           │   ├── resume.rs
│           │   ├── run.rs
│           │   ├── spec_json.rs
│           │   ├── start.rs
│           │   ├── state.rs
│           │   └── update.rs
│           ├── main.rs
│           ├── observability.rs
│           ├── rootpath.rs
│           └── workload/
│               ├── executor.rs
│               ├── mod.rs
│               ├── wasmedge.rs
│               ├── wasmer.rs
│               └── wasmtime.rs
├── cross/
│   ├── Dockerfile.gnu
│   └── Dockerfile.musl
├── docs/
│   ├── .gitignore
│   ├── book.toml
│   ├── doc-draft.md
│   └── src/
│       ├── SUMMARY.md
│       ├── community/
│       │   ├── adopters_and_use_cases.md
│       │   ├── chat.md
│       │   ├── contributing.md
│       │   ├── governance.md
│       │   ├── introduction.md
│       │   └── maintainer.md
│       ├── developer/
│       │   ├── basics.md
│       │   ├── crate_specific_information.md
│       │   ├── debugging.md
│       │   ├── documentation_mdbook.md
│       │   ├── e2e/
│       │   │   ├── containerd_integration_test_using_youki.md
│       │   │   ├── e2e_tests.md
│       │   │   ├── integration_test.md
│       │   │   ├── kubernetes_test.md
│       │   │   ├── runc_compatibility_test.md
│       │   │   ├── runtime_tools.md
│       │   │   ├── runtimetest.md
│       │   │   ├── rust_oci_test.md
│       │   │   └── test_framework.md
│       │   ├── good_places_to_start.md
│       │   ├── introduction.md
│       │   ├── libcgroups.md
│       │   ├── libcontainer.md
│       │   ├── liboci_cli.md
│       │   ├── libseccomp.md
│       │   ├── repo_structure.md
│       │   ├── runtimetest.md
│       │   ├── unwritten_rules.md
│       │   └── youki.md
│       ├── user/
│       │   ├── basic_setup.md
│       │   ├── basic_usage.md
│       │   ├── crates.md
│       │   ├── introduction.md
│       │   ├── libcgroups.md
│       │   ├── libcontainer.md
│       │   ├── liboci_cli.md
│       │   ├── libseccomp.md
│       │   └── webassembly.md
│       └── youki.md
├── experiment/
│   ├── seccomp/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── rust-toolchain.toml
│   │   └── src/
│   │       ├── instruction/
│   │       │   ├── arch.rs
│   │       │   ├── consts.rs
│   │       │   ├── inst.rs
│   │       │   └── mod.rs
│   │       ├── lib.rs
│   │       ├── main.rs
│   │       └── seccomp.rs
│   └── selinux/
│       ├── Cargo.toml
│       ├── README.md
│       ├── lima-run.sh
│       ├── lima-setup.sh
│       ├── provision_system.sh
│       └── src/
│           ├── lib.rs
│           ├── main.rs
│           ├── selinux.rs
│           ├── selinux_label.rs
│           └── tools/
│               ├── mod.rs
│               ├── sockopt.rs
│               └── xattr.rs
├── hack/
│   ├── busctl.sh
│   ├── debug.bt
│   ├── set_root_login_for_vagrant.sh
│   └── stress_cargo_test.sh
├── justfile
├── rust-toolchain.toml
├── rustfmt.toml
├── scripts/
│   ├── .gitignore
│   ├── README.md
│   ├── build.sh
│   ├── cargo.sh
│   ├── clean.sh
│   ├── contest.sh
│   ├── features_test.sh
│   ├── oci_integration_tests.sh
│   └── release_tag.sh
├── tests/
│   ├── .gitignore
│   ├── contest/
│   │   ├── contest/
│   │   │   ├── .gitignore
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   └── src/
│   │   │       ├── lib.rs
│   │   │       ├── logger.rs
│   │   │       ├── main.rs
│   │   │       ├── tests/
│   │   │       │   ├── cgroups/
│   │   │       │   │   ├── blkio.rs
│   │   │       │   │   ├── cpu/
│   │   │       │   │   │   ├── mod.rs
│   │   │       │   │   │   ├── v1.rs
│   │   │       │   │   │   └── v2.rs
│   │   │       │   │   ├── memory.rs
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   ├── network/
│   │   │       │   │   │   ├── absolute_network.rs
│   │   │       │   │   │   ├── mod.rs
│   │   │       │   │   │   └── relative_network.rs
│   │   │       │   │   └── pids.rs
│   │   │       │   ├── create_runtime/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── delete/
│   │   │       │   │   ├── delete_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── devices/
│   │   │       │   │   ├── devices_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── domainname/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── example/
│   │   │       │   │   ├── hello_world.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── exec/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── mount_test.rs
│   │   │       │   ├── exec_cpu_affinity/
│   │   │       │   │   ├── exec_cpu_affinity_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── exec_env/
│   │   │       │   │   ├── exec_env_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── fd_control/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── hooks/
│   │   │       │   │   ├── invoke.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── hostname/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── intel_rdt/
│   │   │       │   │   ├── intel_rdt_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── io_priority/
│   │   │       │   │   ├── io_priority_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── kill/
│   │   │       │   │   ├── kill_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── kill_no_effect/
│   │   │       │   │   ├── kill_no_effect_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── lifecycle/
│   │   │       │   │   ├── checkpoint.rs
│   │   │       │   │   ├── container_create.rs
│   │   │       │   │   ├── container_lifecycle.rs
│   │   │       │   │   ├── create.rs
│   │   │       │   │   ├── delete.rs
│   │   │       │   │   ├── exec.rs
│   │   │       │   │   ├── kill.rs
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   ├── start.rs
│   │   │       │   │   ├── state.rs
│   │   │       │   │   └── util.rs
│   │   │       │   ├── linux_masked_paths/
│   │   │       │   │   ├── masked_paths.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── linux_ns_itype/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── ns_itype_test.rs
│   │   │       │   ├── memory_policy/
│   │   │       │   │   ├── memory_policy_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── misc_props/
│   │   │       │   │   ├── misc_props_test.rs
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── mod.rs
│   │   │       │   ├── mounts_recursive/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── net_devices/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── net_devices_test.rs
│   │   │       │   ├── no_pivot/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── personality/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── pidfile/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── pidfile_test.rs
│   │   │       │   ├── poststart/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── poststart_fail/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── poststop/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── prestart/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── prestart_fail/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── process/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_test.rs
│   │   │       │   ├── process_capabilities_fail/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_capabilities_fail_test.rs
│   │   │       │   ├── process_oom_score_adj/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_oom_score_adj_test.rs
│   │   │       │   ├── process_rlimits/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_rlimits_test.rs
│   │   │       │   ├── process_rlimits_fail/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_rlimits_fail_test.rs
│   │   │       │   ├── process_user/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── process_user_test.rs
│   │   │       │   ├── prohibit_symlink/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── prohibit_symlink_test.rs
│   │   │       │   ├── readonly_paths/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── readonly_paths_tests.rs
│   │   │       │   ├── root_readonly_true/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── root_readonly_tests.rs
│   │   │       │   ├── rootfs_propagation/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── rootfs_propagation_test.rs
│   │   │       │   ├── scheduler/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── scheduler_policy.rs
│   │   │       │   ├── seccomp/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── seccomp_notify/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── seccomp_agent.rs
│   │   │       │   ├── sysctl/
│   │   │       │   │   └── mod.rs
│   │   │       │   ├── tlb/
│   │   │       │   │   ├── mod.rs
│   │   │       │   │   └── tlb_test.rs
│   │   │       │   └── uid_mappings/
│   │   │       │       ├── mod.rs
│   │   │       │       └── uid_mappings_test.rs
│   │   │       └── utils/
│   │   │           ├── mod.rs
│   │   │           ├── support.rs
│   │   │           └── test_utils.rs
│   │   ├── runtimetest/
│   │   │   ├── .cargo/
│   │   │   │   └── config.toml
│   │   │   ├── Cargo.toml
│   │   │   ├── README.md
│   │   │   └── src/
│   │   │       ├── main.rs
│   │   │       ├── tests.rs
│   │   │       └── utils.rs
│   │   └── test_framework/
│   │       ├── Cargo.toml
│   │       ├── README.md
│   │       └── src/
│   │           ├── conditional_test.rs
│   │           ├── lib.rs
│   │           ├── test.rs
│   │           ├── test_group.rs
│   │           ├── test_manager.rs
│   │           └── testable.rs
│   ├── dind/
│   │   ├── daemon.json
│   │   └── run.sh
│   ├── k8s/
│   │   ├── Dockerfile
│   │   └── deploy.yaml
│   ├── rootless-tests/
│   │   └── run.sh
│   └── runc/
│       ├── runc_integration_test.sh
│       └── runc_test_pattern
└── tools/
    └── wasm-sample/
        ├── Cargo.toml
        ├── README.md
        └── src/
            └── main.rs

SYMBOL INDEX (2688 symbols across 258 files)

FILE: crates/libcgroups/examples/bpf.rs
  constant LICENSE (line 15) | const LICENSE: &str = "Apache";
  function cli (line 16) | fn cli() -> Command {
  function parse_cgroupv1_device_rules (line 46) | fn parse_cgroupv1_device_rules<P: AsRef<Path>>(path: P) -> Result<Vec<Li...
  function run (line 52) | pub fn run() -> Result<()> {
  function run (line 99) | pub fn run() -> Result<()> {
  function main (line 108) | fn main() -> Result<()> {

FILE: crates/libcgroups/examples/systemd_io.rs
  function main (line 10) | fn main() -> Result<()> {

FILE: crates/libcgroups/src/common.rs
  constant CGROUP_PROCS (line 18) | pub const CGROUP_PROCS: &str = "cgroup.procs";
  constant DEFAULT_CGROUP_ROOT (line 19) | pub const DEFAULT_CGROUP_ROOT: &str = "/sys/fs/cgroup";
  function is_true_root (line 23) | fn is_true_root() -> Result<bool, WrappedIoError> {
  type CgroupManager (line 34) | pub trait CgroupManager {
    method add_task (line 38) | fn add_task(&self, pid: Pid) -> Result<(), Self::Error>;
    method apply (line 41) | fn apply(&self, controller_opt: &ControllerOpt) -> Result<(), Self::Er...
    method remove (line 44) | fn remove(&self) -> Result<(), Self::Error>;
    method freeze (line 47) | fn freeze(&self, state: FreezerState) -> Result<(), Self::Error>;
    method stats (line 50) | fn stats(&self) -> Result<Stats, Self::Error>;
    method get_all_pids (line 53) | fn get_all_pids(&self) -> Result<Vec<Pid>, Self::Error>;
    type Error (line 74) | type Error = AnyManagerError;
    method add_task (line 76) | fn add_task(&self, pid: Pid) -> Result<(), Self::Error> {
    method apply (line 84) | fn apply(&self, controller_opt: &ControllerOpt) -> Result<(), Self::Er...
    method remove (line 92) | fn remove(&self) -> Result<(), Self::Error> {
    method freeze (line 100) | fn freeze(&self, state: FreezerState) -> Result<(), Self::Error> {
    method stats (line 108) | fn stats(&self) -> Result<Stats, Self::Error> {
    method get_all_pids (line 116) | fn get_all_pids(&self) -> Result<Vec<Pid>, Self::Error> {
  type AnyManagerError (line 57) | pub enum AnyManagerError {
  type AnyCgroupManager (line 67) | pub enum AnyCgroupManager {
  type CgroupSetup (line 126) | pub enum CgroupSetup {
  method fmt (line 133) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type FreezerState (line 146) | pub enum FreezerState {
  type ControllerOpt (line 157) | pub struct ControllerOpt<'a> {
  type WrappedIoError (line 169) | pub enum WrappedIoError {
    method inner (line 187) | pub fn inner(&self) -> &std::io::Error {
  function write_cgroup_file_str (line 199) | pub fn write_cgroup_file_str<P: AsRef<Path>>(path: P, data: &str) -> Res...
  function write_cgroup_file (line 222) | pub fn write_cgroup_file<P: AsRef<Path>, T: ToString>(
  function read_cgroup_file (line 249) | pub fn read_cgroup_file<P: AsRef<Path>>(path: P) -> Result<String, Wrapp...
  type GetCgroupSetupError (line 258) | pub enum GetCgroupSetupError {
  function get_cgroup_setup_with_root (line 275) | pub fn get_cgroup_setup_with_root(root_path: &Path) -> Result<CgroupSetu...
  function get_cgroup_setup (line 309) | pub fn get_cgroup_setup() -> Result<CgroupSetup, GetCgroupSetupError> {
  type CreateCgroupSetupError (line 314) | pub enum CreateCgroupSetupError {
  type CgroupConfig (line 330) | pub struct CgroupConfig {
  function create_cgroup_manager_with_root (line 338) | pub fn create_cgroup_manager_with_root(
  function create_cgroup_manager (line 371) | pub fn create_cgroup_manager(
  function create_v1_cgroup_manager (line 378) | fn create_v1_cgroup_manager(
  function create_v1_cgroup_manager (line 386) | fn create_v1_cgroup_manager(
  function create_v2_cgroup_manager (line 393) | fn create_v2_cgroup_manager(
  function create_v2_cgroup_manager (line 402) | fn create_v2_cgroup_manager(
  function create_systemd_cgroup_manager (line 410) | fn create_systemd_cgroup_manager(
  function create_systemd_cgroup_manager (line 439) | fn create_systemd_cgroup_manager(
  function get_all_pids (line 447) | pub fn get_all_pids(path: &Path) -> Result<Vec<Pid>, WrappedIoError> {
  function walk_dir (line 467) | fn walk_dir<F, E>(path: &Path, c: &mut F) -> Result<(), E>
  type PathBufExt (line 484) | pub(crate) trait PathBufExt {
    method join_safely (line 485) | fn join_safely<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf, Join...
    method join_safely (line 498) | fn join_safely<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf, Join...
  type JoinSafelyError (line 489) | pub enum JoinSafelyError {
  function default_allow_devices (line 515) | pub(crate) fn default_allow_devices() -> Vec<LinuxDeviceCgroup> {
  function default_devices (line 567) | pub(crate) fn default_devices() -> Vec<LinuxDevice> {
  function delete_with_retry (line 621) | pub(crate) fn delete_with_retry<P: AsRef<Path>, L: Into<Option<Duration>>>(
  type WrapIoResult (line 651) | pub(crate) trait WrapIoResult {
    method wrap_create_dir (line 654) | fn wrap_create_dir<P: Into<PathBuf>>(self, path: P) -> Result<Self::Ta...
    method wrap_read (line 655) | fn wrap_read<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target, ...
    method wrap_open (line 656) | fn wrap_open<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target, ...
    method wrap_write (line 657) | fn wrap_write<P: Into<PathBuf>, D: Into<String>>(
    method wrap_other (line 662) | fn wrap_other<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target,...
    type Target (line 666) | type Target = T;
    method wrap_create_dir (line 668) | fn wrap_create_dir<P: Into<PathBuf>>(self, path: P) -> Result<Self::Ta...
    method wrap_read (line 675) | fn wrap_read<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target, ...
    method wrap_open (line 682) | fn wrap_open<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target, ...
    method wrap_write (line 689) | fn wrap_write<P: Into<PathBuf>, D: Into<String>>(
    method wrap_other (line 701) | fn wrap_other<P: Into<PathBuf>>(self, path: P) -> Result<Self::Target,...
  type EitherError (line 710) | pub enum EitherError<L, R> {
  method fmt (line 716) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type MustBePowerOfTwo (line 727) | pub struct MustBePowerOfTwo;
  method fmt (line 730) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: crates/libcgroups/src/stats.rs
  type StatsProvider (line 12) | pub(crate) trait StatsProvider {
    method stats (line 16) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error>;
  type Stats (line 21) | pub struct Stats {
  type CpuStats (line 36) | pub struct CpuStats {
  type CpuUsage (line 47) | pub struct CpuUsage {
  type CpuThrottling (line 64) | pub struct CpuThrottling {
  type MemoryStats (line 75) | pub struct MemoryStats {
  type MemoryData (line 96) | pub struct MemoryData {
  type PidStats (line 109) | pub struct PidStats {
  type BlkioStats (line 118) | pub struct BlkioStats {
  type BlkioDeviceStat (line 141) | pub struct BlkioDeviceStat {
  method fmt (line 153) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type HugeTlbStats (line 168) | pub struct HugeTlbStats {
  type PSIStats (line 179) | pub struct PSIStats {
  type PSIData (line 187) | pub struct PSIData {
  type SupportedPageSizesError (line 197) | pub enum SupportedPageSizesError {
  function supported_page_sizes (line 207) | pub fn supported_page_sizes() -> Result<Vec<String>, SupportedPageSizesE...
  function extract_page_size (line 226) | fn extract_page_size(dir_name: &str) -> Result<String, SupportedPageSize...
  function parse_value (line 260) | pub fn parse_value(value: &str) -> Result<u64, ParseIntError> {
  function parse_single_value (line 273) | pub fn parse_single_value(file_path: &Path) -> Result<u64, WrappedIoErro...
  type ParseFlatKeyedDataError (line 287) | pub enum ParseFlatKeyedDataError {
  function parse_flat_keyed_data (line 301) | pub(crate) fn parse_flat_keyed_data(
  type ParseNestedKeyedDataError (line 330) | pub enum ParseNestedKeyedDataError {
  function parse_nested_keyed_data (line 338) | pub fn parse_nested_keyed_data(
  type ParseDeviceNumberError (line 365) | pub enum ParseDeviceNumberError {
  function parse_device_number (line 372) | pub(crate) fn parse_device_number(device: &str) -> Result<(u64, u64), Pa...
  type PidStatsError (line 398) | pub enum PidStatsError {
  function pid_stats (line 408) | pub fn pid_stats(cgroup_path: &Path) -> Result<PidStats, PidStatsError> {
  function psi_stats (line 426) | pub fn psi_stats(psi_file: &Path) -> Result<PSIStats, WrappedIoError> {
  function parse_psi (line 441) | fn parse_psi(stat_line: &str, path: &Path) -> Result<PSIData, WrappedIoE...
  function test_supported_page_sizes_gigabyte (line 479) | fn test_supported_page_sizes_gigabyte() {
  function test_supported_page_sizes_megabyte (line 485) | fn test_supported_page_sizes_megabyte() {
  function test_supported_page_sizes_kilobyte (line 491) | fn test_supported_page_sizes_kilobyte() {
  function test_parse_single_value_valid (line 497) | fn test_parse_single_value_valid() {
  function test_parse_single_value_invalid_number (line 506) | fn test_parse_single_value_invalid_number() {
  function test_parse_single_value_multiple_entries (line 515) | fn test_parse_single_value_multiple_entries() {
  function test_parse_flat_keyed_data (line 524) | fn test_parse_flat_keyed_data() {
  function test_parse_flat_keyed_data_with_characters (line 539) | fn test_parse_flat_keyed_data_with_characters() {
  function test_parse_space_separated_as_flat_keyed_data (line 549) | fn test_parse_space_separated_as_flat_keyed_data() {
  function test_parse_newline_separated_as_flat_keyed_data (line 559) | fn test_parse_newline_separated_as_flat_keyed_data() {
  function test_parse_nested_keyed_data_as_flat_keyed_data (line 569) | fn test_parse_nested_keyed_data_as_flat_keyed_data() {
  function test_parse_nested_keyed_data (line 584) | fn test_parse_nested_keyed_data() {
  function test_parse_space_separated_as_nested_keyed_data (line 625) | fn test_parse_space_separated_as_nested_keyed_data() {
  function test_parse_newline_separated_as_nested_keyed_data (line 635) | fn test_parse_newline_separated_as_nested_keyed_data() {
  function test_parse_flat_keyed_as_nested_keyed_data (line 645) | fn test_parse_flat_keyed_as_nested_keyed_data() {
  function test_parse_device_number (line 655) | fn test_parse_device_number() {
  function test_parse_invalid_device_number (line 661) | fn test_parse_invalid_device_number() {
  function test_parse_psi_full_stats (line 667) | fn test_parse_psi_full_stats() {
  function test_parse_psi_only_some (line 695) | fn test_parse_psi_only_some() {

FILE: crates/libcgroups/src/stub/systemd/manager.rs
  type SystemdManagerError (line 4) | pub enum SystemdManagerError {
  type Manager (line 9) | pub struct Manager {}
    method any (line 12) | pub fn any(self) -> AnyCgroupManager {
  type Error (line 18) | type Error = SystemdManagerError;
  method add_task (line 20) | fn add_task(&self, _pid: nix::unistd::Pid) -> Result<(), Self::Error> {
  method apply (line 24) | fn apply(&self, _controller_opt: &crate::common::ControllerOpt) -> Resul...
  method remove (line 28) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 32) | fn freeze(&self, _state: crate::common::FreezerState) -> Result<(), Self...
  method stats (line 36) | fn stats(&self) -> Result<crate::stats::Stats, Self::Error> {
  method get_all_pids (line 40) | fn get_all_pids(&self) -> Result<Vec<nix::unistd::Pid>, Self::Error> {

FILE: crates/libcgroups/src/stub/v1/manager.rs
  type V1ManagerError (line 4) | pub enum V1ManagerError {
  type Manager (line 9) | pub struct Manager {}
    method any (line 12) | pub fn any(self) -> AnyCgroupManager {
  type Error (line 18) | type Error = V1ManagerError;
  method add_task (line 20) | fn add_task(&self, _pid: nix::unistd::Pid) -> Result<(), Self::Error> {
  method apply (line 24) | fn apply(&self, _controller_opt: &crate::common::ControllerOpt) -> Resul...
  method remove (line 28) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 32) | fn freeze(&self, _state: crate::common::FreezerState) -> Result<(), Self...
  method stats (line 36) | fn stats(&self) -> Result<crate::stats::Stats, Self::Error> {
  method get_all_pids (line 40) | fn get_all_pids(&self) -> Result<Vec<nix::unistd::Pid>, Self::Error> {

FILE: crates/libcgroups/src/stub/v2/manager.rs
  type V2ManagerError (line 4) | pub enum V2ManagerError {
  type Manager (line 9) | pub struct Manager {}
    method any (line 12) | pub fn any(self) -> AnyCgroupManager {
  type Error (line 18) | type Error = V2ManagerError;
  method add_task (line 20) | fn add_task(&self, _pid: nix::unistd::Pid) -> Result<(), Self::Error> {
  method apply (line 24) | fn apply(&self, _controller_opt: &crate::common::ControllerOpt) -> Resul...
  method remove (line 28) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 32) | fn freeze(&self, _state: crate::common::FreezerState) -> Result<(), Self...
  method stats (line 36) | fn stats(&self) -> Result<crate::stats::Stats, Self::Error> {
  method get_all_pids (line 40) | fn get_all_pids(&self) -> Result<Vec<nix::unistd::Pid>, Self::Error> {

FILE: crates/libcgroups/src/systemd/controller.rs
  type Controller (line 6) | pub(super) trait Controller {
    method apply (line 9) | fn apply(

FILE: crates/libcgroups/src/systemd/controller_type.rs
  type ControllerType (line 3) | pub enum ControllerType {
    method as_ref (line 26) | fn as_ref(&self) -> &str {
  method fmt (line 12) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  constant CONTROLLER_TYPES (line 37) | pub const CONTROLLER_TYPES: &[ControllerType] = &[

FILE: crates/libcgroups/src/systemd/cpu.rs
  constant CPU_WEIGHT (line 9) | pub const CPU_WEIGHT: &str = "CPUWeight";
  constant CPU_QUOTA (line 10) | pub const CPU_QUOTA: &str = "CPUQuotaPerSecUSec";
  constant CPU_PERIOD (line 11) | pub const CPU_PERIOD: &str = "CPUQuotaPeriodUSec";
  constant MICROSECS_PER_SEC (line 12) | const MICROSECS_PER_SEC: u64 = 1_000_000;
  type SystemdCpuError (line 15) | pub enum SystemdCpuError {
  type Cpu (line 20) | pub(crate) struct Cpu {}
    method apply (line 40) | fn apply(
    method is_realtime_requested (line 84) | fn is_realtime_requested(cpu: &LinuxCpu) -> bool {
  type Error (line 23) | type Error = SystemdCpuError;
  method apply (line 25) | fn apply(
  function convert_shares_to_cgroup2 (line 97) | pub fn convert_shares_to_cgroup2(shares: u64) -> u64 {
  function test_set_shares (line 130) | fn test_set_shares() -> Result<()> {
  function test_set_quota (line 152) | fn test_set_quota() -> Result<()> {
  function test_set_period (line 174) | fn test_set_period() -> Result<()> {

FILE: crates/libcgroups/src/systemd/cpuset.rs
  constant ALLOWED_CPUS (line 10) | pub const ALLOWED_CPUS: &str = "AllowedCPUs";
  constant ALLOWED_NODES (line 11) | pub const ALLOWED_NODES: &str = "AllowedMemoryNodes";
  type SystemdCpuSetError (line 14) | pub enum SystemdCpuSetError {
  type CpuSet (line 23) | pub struct CpuSet {}
    method apply (line 43) | fn apply(
  type Error (line 26) | type Error = SystemdCpuSetError;
  method apply (line 28) | fn apply(
  type BitmaskError (line 75) | pub enum BitmaskError {
  function to_bitmask (line 85) | pub fn to_bitmask(range: &str) -> Result<Vec<u8>, BitmaskError> {
  function to_bitmask_single_value (line 145) | fn to_bitmask_single_value() -> Result<()> {
  function to_bitmask_multiple_single_values (line 156) | fn to_bitmask_multiple_single_values() -> Result<()> {
  function to_bitmask_range_value (line 167) | fn to_bitmask_range_value() -> Result<()> {
  function to_bitmask_interchanged_range (line 178) | fn to_bitmask_interchanged_range() -> Result<()> {
  function to_bitmask_incomplete_range (line 187) | fn to_bitmask_incomplete_range() -> Result<()> {
  function to_bitmask_mixed (line 199) | fn to_bitmask_mixed() -> Result<()> {
  function to_bitmask_extra_characters (line 211) | fn to_bitmask_extra_characters() -> Result<()> {
  function test_cpuset_systemd_too_old (line 223) | fn test_cpuset_systemd_too_old() -> Result<()> {
  function test_cpuset_set (line 237) | fn test_cpuset_set() -> Result<()> {

FILE: crates/libcgroups/src/systemd/dbus_native/client.rs
  type SystemdClient (line 7) | pub trait SystemdClient {
    method is_system (line 9) | fn is_system(&self) -> bool;
    method transient_unit_exists (line 11) | fn transient_unit_exists(&self, unit_name: &str) -> bool;
    method start_transient_unit (line 13) | fn start_transient_unit(
    method stop_transient_unit (line 21) | fn stop_transient_unit(&self, unit_name: &str) -> Result<(), SystemdCl...
    method set_unit_properties (line 23) | fn set_unit_properties(
    method systemd_version (line 29) | fn systemd_version(&self) -> Result<u32, SystemdClientError>;
    method control_cgroup_root (line 31) | fn control_cgroup_root(&self) -> Result<PathBuf, SystemdClientError>;
    method add_process_to_unit (line 33) | fn add_process_to_unit(

FILE: crates/libcgroups/src/systemd/dbus_native/dbus.rs
  constant REPLY_BUF_SIZE (line 16) | const REPLY_BUF_SIZE: usize = 128;
  type DbusConnection (line 24) | pub struct DbusConnection {
    method new (line 132) | pub fn new(addr: &str, uid: u32, system: bool) -> Result<Self> {
    method new_system (line 153) | pub fn new_system() -> Result<Self> {
    method new_session (line 158) | pub fn new_session() -> Result<Self> {
    method authenticate (line 166) | fn authenticate(&mut self, uid: u32) -> Result<()> {
    method receive_complete_response (line 247) | fn receive_complete_response(&self) -> Result<Vec<u8>> {
    method send_message (line 283) | pub fn send_message(
    method get_msg_id (line 353) | fn get_msg_id(&self) -> u32 {
    method proxy (line 359) | pub fn proxy(&self, destination: &str, path: &str) -> Proxy<'_> {
    method create_proxy (line 363) | fn create_proxy(&self) -> Proxy<'_> {
  function uid_to_hex_str (line 39) | fn uid_to_hex_str(uid: u32) -> String {
  function parse_dbus_address (line 48) | fn parse_dbus_address(env_value: String) -> Result<String> {
  function get_session_bus_address (line 67) | fn get_session_bus_address() -> Result<String> {
  function get_system_bus_address (line 90) | fn get_system_bus_address() -> Result<String> {
  function get_actual_uid (line 101) | fn get_actual_uid() -> Result<u32> {
  method is_system (line 369) | fn is_system(&self) -> bool {
  method transient_unit_exists (line 373) | fn transient_unit_exists(&self, unit_name: &str) -> bool {
  method start_transient_unit (line 381) | fn start_transient_unit(
  method stop_transient_unit (line 438) | fn stop_transient_unit(&self, unit_name: &str) -> Result<()> {
  method set_unit_properties (line 450) | fn set_unit_properties(
  method systemd_version (line 471) | fn systemd_version(&self) -> std::result::Result<u32, SystemdClientError> {
  method control_cgroup_root (line 486) | fn control_cgroup_root(&self) -> std::result::Result<PathBuf, SystemdCli...
  method add_process_to_unit (line 492) | fn add_process_to_unit(&self, unit_name: &str, subcgroup: &str, pid: u32...
  function test_uid_to_hex_str (line 506) | fn test_uid_to_hex_str() {
  function test_dbus_connection_auth (line 515) | fn test_dbus_connection_auth() {
  function test_dbus_function_calls (line 529) | fn test_dbus_function_calls() -> Result<()> {
  function test_dbus_function_calls_errors (line 567) | fn test_dbus_function_calls_errors() {

FILE: crates/libcgroups/src/systemd/dbus_native/message.rs
  type Endian (line 5) | pub enum Endian {
    method to_byte (line 11) | fn to_byte(&self) -> u8 {
    method from_byte (line 17) | fn from_byte(byte: u8) -> Self {
  type HeaderSignature (line 29) | pub enum HeaderSignature {
    method to_byte (line 37) | fn to_byte(&self) -> u8 {
    method from_byte (line 45) | fn from_byte(byte: u8) -> Self {
  type MessageType (line 58) | pub enum MessageType {
  type HeaderKind (line 67) | pub enum HeaderKind {
    method signature (line 80) | fn signature(&self) -> HeaderSignature {
  type HeaderValue (line 94) | pub enum HeaderValue {
    method as_bytes (line 100) | fn as_bytes(&self) -> Vec<u8> {
    method len (line 111) | fn len(&self) -> usize {
  type Header (line 120) | pub struct Header {
    method parse (line 128) | fn parse(buf: &[u8], ctr: &mut usize) -> Result<Self> {
  type Preamble (line 240) | pub struct Preamble {
    method new (line 248) | fn new(mtype: MessageType) -> Self {
  type Message (line 260) | pub struct Message {
    method new (line 273) | pub fn new(mtype: MessageType, serial: u32, headers: Vec<Header>, body...
    method serialize (line 352) | pub fn serialize(mut self) -> Vec<u8> {
    method deserialize (line 394) | pub fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
  function serialize_headers (line 287) | fn serialize_headers(headers: &[Header]) -> Vec<u8> {
  function deserialize_headers (line 336) | fn deserialize_headers(buf: &[u8]) -> Result<Vec<Header>> {
  function test_method_call_deserialize (line 500) | fn test_method_call_deserialize() -> Result<()> {
  function test_method_reply_deserialize (line 560) | fn test_method_reply_deserialize() -> Result<()> {
  function test_signal_deserialize (line 608) | fn test_signal_deserialize() -> Result<()> {
  function test_no_body_deserialize (line 663) | fn test_no_body_deserialize() -> Result<()> {
  function test_error_message_deserialize (line 705) | fn test_error_message_deserialize() -> Result<()> {
  function test_vector_payload_deserialize (line 756) | fn test_vector_payload_deserialize() -> Result<()> {

FILE: crates/libcgroups/src/systemd/dbus_native/proxy.rs
  type Proxy (line 8) | pub struct Proxy<'conn> {
  function check_signature_compatibility (line 18) | fn check_signature_compatibility(actual: &str, expected: &str) -> bool {
  function new (line 34) | pub fn new(conn: &'conn DbusConnection, dest: &str, path: &str) -> Self {
  function method_call (line 44) | pub fn method_call<Body: DbusSerialize, Output: DbusSerialize>(
  function get_unit (line 170) | pub fn get_unit(&mut self, name: &str) -> Result<String> {
  function start_transient_unit (line 183) | pub fn start_transient_unit(
  function stop_unit (line 197) | pub fn stop_unit(&self, name: &str, mode: &str) -> Result<String> {
  function set_unit_properties (line 205) | pub fn set_unit_properties(
  function version (line 218) | pub fn version(&self) -> Result<String> {
  function control_group (line 230) | pub fn control_group(&self) -> Result<String> {
  function attach_process (line 244) | pub fn attach_process(&self, name: &str, cgroup: &str, pid: u32) -> Resu...

FILE: crates/libcgroups/src/systemd/dbus_native/serialize.rs
  type DbusSerialize (line 5) | pub trait DbusSerialize: std::fmt::Debug {
    method get_signature (line 7) | fn get_signature() -> String
    method get_alignment (line 11) | fn get_alignment() -> usize;
    method serialize (line 15) | fn serialize(&self, buf: &mut Vec<u8>);
    method deserialize (line 21) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self>
    method get_signature (line 56) | fn get_signature() -> String {
    method get_alignment (line 59) | fn get_alignment() -> usize {
    method serialize (line 62) | fn serialize(&self, _: &mut Vec<u8>) {}
    method deserialize (line 64) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 71) | fn get_signature() -> String {
    method get_alignment (line 74) | fn get_alignment() -> usize {
    method serialize (line 77) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 81) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 91) | fn get_signature() -> String {
    method get_alignment (line 100) | fn get_alignment() -> usize {
    method serialize (line 103) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 109) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 119) | fn get_signature() -> String {
    method get_alignment (line 127) | fn get_alignment() -> usize {
    method serialize (line 130) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 135) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 144) | fn get_signature() -> String {
    method get_alignment (line 147) | fn get_alignment() -> usize {
    method serialize (line 150) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 158) | fn deserialize(_: &[u8], _: &mut usize) -> Result<Self> {
    method get_signature (line 167) | fn get_signature() -> String {
    method get_alignment (line 170) | fn get_alignment() -> usize {
    method serialize (line 173) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 181) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 204) | fn get_signature() -> String {
    method get_alignment (line 207) | fn get_alignment() -> usize {
    method serialize (line 210) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 218) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 233) | fn get_signature() -> String {
    method get_alignment (line 236) | fn get_alignment() -> usize {
    method serialize (line 239) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 243) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 258) | fn get_signature() -> String {
    method get_alignment (line 261) | fn get_alignment() -> usize {
    method serialize (line 264) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 268) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 283) | fn get_signature() -> String {
    method get_alignment (line 286) | fn get_alignment() -> usize {
    method serialize (line 289) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 293) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 308) | fn get_signature() -> String {
    method get_alignment (line 311) | fn get_alignment() -> usize {
    method serialize (line 314) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 318) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 333) | fn get_signature() -> String {
    method get_alignment (line 337) | fn get_alignment() -> usize {
    method serialize (line 340) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 353) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 387) | fn get_signature() -> String {
    method get_alignment (line 391) | fn get_alignment() -> usize {
    method serialize (line 394) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 399) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
    method get_signature (line 408) | fn get_signature() -> String {
    method get_alignment (line 411) | fn get_alignment() -> usize {
    method serialize (line 414) | fn serialize(&self, buf: &mut Vec<u8>) {
    method deserialize (line 467) | fn deserialize(buf: &[u8], counter: &mut usize) -> Result<Self> {
  type Variant (line 27) | pub enum Variant {
  type Structure (line 44) | pub struct Structure<T: DbusSerialize> {
  function new (line 50) | pub fn new(key: String, val: T) -> Self {

FILE: crates/libcgroups/src/systemd/dbus_native/utils.rs
  type SystemdClientError (line 4) | pub enum SystemdClientError {
    method from (line 52) | fn from(err: nix::Error) -> SystemdClientError {
  type DbusError (line 28) | pub enum DbusError {
  type Result (line 49) | pub type Result<T> = std::result::Result<T, SystemdClientError>;
  function adjust_padding (line 59) | pub fn adjust_padding(buf: &mut Vec<u8>, align: usize) {
  function align_counter (line 71) | pub fn align_counter(ctr: &mut usize, align: usize) {
  function test_adjust_padding (line 83) | fn test_adjust_padding() {
  function test_align_counter (line 128) | fn test_align_counter() {

FILE: crates/libcgroups/src/systemd/io.rs
  type Io (line 9) | pub struct Io {}
    method apply (line 36) | fn apply(
  constant IO_READ_BANDWIDTH_MAX (line 11) | pub const IO_READ_BANDWIDTH_MAX: &str = "IOReadBandwidthMax";
  constant IO_WRITE_BANDWIDTH_MAX (line 12) | pub const IO_WRITE_BANDWIDTH_MAX: &str = "IOWriteBandwidthMax";
  constant IO_READ_IOPS_MAX (line 13) | pub const IO_READ_IOPS_MAX: &str = "IOReadIOPSMax";
  constant IO_WRITE_IOPS_MAX (line 14) | pub const IO_WRITE_IOPS_MAX: &str = "IOWriteIOPSMax";
  type SystemdIoError (line 17) | pub enum SystemdIoError {
  type Error (line 22) | type Error = SystemdIoError;
  method apply (line 23) | fn apply(
  function dev_path_from_major_minor (line 78) | fn dev_path_from_major_minor(major: i64, minor: i64) -> Option<String> {
  function dev_path_from_char_device_null (line 106) | fn dev_path_from_char_device_null() {
  function apply_inserts_structs_for_positive_rates (line 115) | fn apply_inserts_structs_for_positive_rates() {
  function test_io_apply (line 194) | fn test_io_apply() {

FILE: crates/libcgroups/src/systemd/manager.rs
  constant CGROUP_CONTROLLERS (line 31) | const CGROUP_CONTROLLERS: &str = "cgroup.controllers";
  constant CGROUP_SUBTREE_CONTROL (line 32) | const CGROUP_SUBTREE_CONTROL: &str = "cgroup.subtree_control";
  constant PROCESS_IN_CGROUP_TIMEOUT_DURATION (line 33) | pub const PROCESS_IN_CGROUP_TIMEOUT_DURATION: Duration = Duration::from_...
  type Manager (line 35) | pub struct Manager {
    method new (line 182) | pub fn new(
    method get_unit_name (line 218) | fn get_unit_name(cgroups_path: &CgroupsPath) -> String {
    method construct_cgroups_path (line 229) | fn construct_cgroups_path(
    method expand_slice (line 247) | fn expand_slice(slice: &str) -> Result<PathBuf, SystemdManagerError> {
    method ensure_controllers_attached (line 275) | fn ensure_controllers_attached(&self) -> Result<(), SystemdManagerErro...
    method wait_for_process_in_cgroup (line 320) | fn wait_for_process_in_cgroup(&self, pid: Pid) -> Result<(), SystemdMa...
    method get_available_controllers (line 347) | fn get_available_controllers<P: AsRef<Path>>(
    method write_controllers (line 372) | fn write_controllers(path: &Path, controllers: &[String]) -> Result<()...
    method any (line 380) | pub fn any(self) -> AnyCgroupManager {
  type CgroupsPath (line 64) | struct CgroupsPath {
    type Error (line 81) | type Error = CgroupsPathError;
    method try_from (line 83) | fn try_from(cgroups_path: &Path) -> Result<Self, Self::Error> {
  type CgroupsPathError (line 71) | pub enum CgroupsPathError {
  method fmt (line 115) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function ensure_parent_unit (line 121) | fn ensure_parent_unit(cgroups_path: &mut CgroupsPath, use_system: bool) {
  method fmt (line 133) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type SystemdManagerError (line 146) | pub enum SystemdManagerError {
  type Error (line 386) | type Error = SystemdManagerError;
  method add_task (line 388) | fn add_task(&self, pid: Pid) -> Result<(), Self::Error> {
  method apply (line 414) | fn apply(&self, controller_opt: &ControllerOpt) -> Result<(), Self::Erro...
  method remove (line 453) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 462) | fn freeze(&self, state: FreezerState) -> Result<(), Self::Error> {
  method stats (line 466) | fn stats(&self) -> Result<Stats, Self::Error> {
  method get_all_pids (line 470) | fn get_all_pids(&self) -> Result<Vec<Pid>, Self::Error> {
  type TestSystemdClient (line 485) | struct TestSystemdClient {}
  method is_system (line 488) | fn is_system(&self) -> bool {
  method transient_unit_exists (line 492) | fn transient_unit_exists(&self, _: &str) -> bool {
  method start_transient_unit (line 496) | fn start_transient_unit(
  method stop_transient_unit (line 506) | fn stop_transient_unit(&self, _unit_name: &str) -> Result<(), SystemdCli...
  method set_unit_properties (line 510) | fn set_unit_properties(
  method systemd_version (line 518) | fn systemd_version(&self) -> Result<u32, SystemdClientError> {
  method control_cgroup_root (line 522) | fn control_cgroup_root(&self) -> Result<PathBuf, SystemdClientError> {
  method add_process_to_unit (line 526) | fn add_process_to_unit(
  function expand_slice_works (line 537) | fn expand_slice_works() -> Result<()> {
  function get_cgroups_path_works_with_a_complex_slice (line 547) | fn get_cgroups_path_works_with_a_complex_slice() -> Result<()> {
  function get_cgroups_path_works_with_a_simple_slice (line 561) | fn get_cgroups_path_works_with_a_simple_slice() -> Result<()> {
  function get_cgroups_path_works_without_parent (line 575) | fn get_cgroups_path_works_without_parent() -> Result<()> {
  function test_task_addition (line 590) | fn test_task_addition() {
  function test_error_thrown_if_process_never_added_to_cgroup (line 624) | fn test_error_thrown_if_process_never_added_to_cgroup() -> Result<()> {

FILE: crates/libcgroups/src/systemd/memory.rs
  constant MEMORY_MIN (line 9) | pub const MEMORY_MIN: &str = "MemoryMin";
  constant MEMORY_LOW (line 10) | pub const MEMORY_LOW: &str = "MemoryLow";
  constant MEMORY_HIGH (line 11) | pub const MEMORY_HIGH: &str = "MemoryHigh";
  constant MEMORY_MAX (line 12) | pub const MEMORY_MAX: &str = "MemoryMax";
  constant MEMORY_SWAP (line 13) | pub const MEMORY_SWAP: &str = "MemorySwapMax";
  type SystemdMemoryError (line 16) | pub enum SystemdMemoryError {
  type Memory (line 25) | pub struct Memory {}
    method apply (line 45) | fn apply(
    method apply_swap (line 82) | fn apply_swap(
  type Error (line 28) | type Error = SystemdMemoryError;
  method apply (line 30) | fn apply(
  function test_set_valid_memory_low (line 124) | fn test_set_valid_memory_low() -> Result<()> {
  function test_set_valid_memory_max (line 150) | fn test_set_valid_memory_max() -> Result<()> {

FILE: crates/libcgroups/src/systemd/mod.rs
  function booted (line 15) | pub fn booted() -> bool {

FILE: crates/libcgroups/src/systemd/pids.rs
  constant TASKS_MAX (line 10) | pub const TASKS_MAX: &str = "TasksMax";
  type Pids (line 12) | pub struct Pids {}
    method apply (line 32) | fn apply(pids: &LinuxPids, properties: &mut HashMap<&str, Variant>) {
  type Error (line 15) | type Error = Infallible;
  method apply (line 17) | fn apply(
  function setup (line 53) | fn setup(resources: &LinuxResources) -> (ControllerOpt<'_>, HashMap<&str...
  function test_pids_positive_limit (line 66) | fn test_pids_positive_limit() -> Result<()> {
  function test_pids_zero_limit (line 87) | fn test_pids_zero_limit() -> Result<()> {
  function test_pids_negative_limit (line 108) | fn test_pids_negative_limit() -> Result<()> {

FILE: crates/libcgroups/src/systemd/unified.rs
  type SystemdUnifiedError (line 12) | pub enum SystemdUnifiedError {
  type Unified (line 35) | pub struct Unified {}
    method apply (line 55) | fn apply(
  type Error (line 38) | type Error = SystemdUnifiedError;
  method apply (line 40) | fn apply(
  function test_set (line 164) | fn test_set() -> Result<()> {
  function test_cpu_max_quota_and_period (line 208) | fn test_cpu_max_quota_and_period() -> Result<()> {
  function test_cpu_max_quota_only (line 232) | fn test_cpu_max_quota_only() -> Result<()> {

FILE: crates/libcgroups/src/test.rs
  function setup (line 8) | pub fn setup(cgroup_file: &str) -> (tempfile::TempDir, PathBuf) {
  function set_fixture (line 16) | pub fn set_fixture(temp_dir: &Path, filename: &str, val: &str) -> Result...

FILE: crates/libcgroups/src/test_manager.rs
  type TestManager (line 10) | pub struct TestManager {
    method get_add_task_args (line 56) | pub fn get_add_task_args(&self) -> Vec<Pid> {
    method apply_called (line 60) | pub fn apply_called(&self) -> bool {
  method default (line 16) | fn default() -> Self {
  type Error (line 25) | type Error = Infallible;
  method add_task (line 27) | fn add_task(&self, pid: Pid) -> Result<(), Infallible> {
  method apply (line 33) | fn apply(&self, _controller_opt: &ControllerOpt) -> Result<(), Infallibl...
  method remove (line 38) | fn remove(&self) -> Result<(), Infallible> {
  method freeze (line 42) | fn freeze(&self, _state: FreezerState) -> Result<(), Infallible> {
  method stats (line 46) | fn stats(&self) -> Result<Stats, Infallible> {
  method get_all_pids (line 50) | fn get_all_pids(&self) -> Result<Vec<Pid>, Infallible> {

FILE: crates/libcgroups/src/v1/blkio.rs
  constant BLKIO_THROTTLE_READ_BPS (line 14) | const BLKIO_THROTTLE_READ_BPS: &str = "blkio.throttle.read_bps_device";
  constant BLKIO_THROTTLE_WRITE_BPS (line 17) | const BLKIO_THROTTLE_WRITE_BPS: &str = "blkio.throttle.write_bps_device";
  constant BLKIO_THROTTLE_READ_IOPS (line 20) | const BLKIO_THROTTLE_READ_IOPS: &str = "blkio.throttle.read_iops_device";
  constant BLKIO_THROTTLE_WRITE_IOPS (line 23) | const BLKIO_THROTTLE_WRITE_IOPS: &str = "blkio.throttle.write_iops_device";
  constant BLKIO_THROTTLE_IO_SERVICED (line 26) | const BLKIO_THROTTLE_IO_SERVICED: &str = "blkio.throttle.io_serviced";
  constant BLKIO_THROTTLE_IO_SERVICE_BYTES (line 29) | const BLKIO_THROTTLE_IO_SERVICE_BYTES: &str = "blkio.throttle.io_service...
  constant BLKIO_WEIGHT (line 35) | const BLKIO_WEIGHT: &str = "blkio.weight";
  constant BLKIO_BFQ_WEIGHT (line 39) | const BLKIO_BFQ_WEIGHT: &str = "blkio.bfq.weight";
  constant BLKIO_WEIGHT_DEVICE (line 44) | const BLKIO_WEIGHT_DEVICE: &str = "blkio.weight_device";
  constant BLKIO_TIME (line 51) | const BLKIO_TIME: &str = "blkio.time_recursive";
  constant BLKIO_SECTORS (line 54) | const BLKIO_SECTORS: &str = "blkio.sectors_recursive";
  constant BLKIO_IO_SERVICE_BYTES (line 57) | const BLKIO_IO_SERVICE_BYTES: &str = "blkio.io_service_bytes_recursive";
  constant BLKIO_IO_SERVICED (line 60) | const BLKIO_IO_SERVICED: &str = "blkio.io_serviced_recursive";
  constant BLKIO_IO_SERVICE_TIME (line 63) | const BLKIO_IO_SERVICE_TIME: &str = "blkio.io_service_time_recursive";
  constant BLKIO_WAIT_TIME (line 66) | const BLKIO_WAIT_TIME: &str = "blkio.io_wait_time_recursive";
  constant BLKIO_QUEUED (line 69) | const BLKIO_QUEUED: &str = "blkio.io_queued_recursive";
  constant BLKIO_MERGED (line 72) | const BLKIO_MERGED: &str = "blkio.io_merged_recursive";
  type Blkio (line 74) | pub struct Blkio {}
    method apply (line 123) | fn apply(root_path: &Path, blkio: &LinuxBlockIo) -> Result<(), Wrapped...
    method get_throttling_policy_stats (line 176) | fn get_throttling_policy_stats(cgroup_path: &Path) -> Result<BlkioStat...
    method get_weight_division_policy_stats (line 188) | fn get_weight_division_policy_stats(
    method parse_blkio_file (line 206) | fn parse_blkio_file(blkio_file: &Path) -> Result<Vec<BlkioDeviceStat>,...
  type Error (line 77) | type Error = WrappedIoError;
  type Resource (line 78) | type Resource = LinuxBlockIo;
  method apply (line 80) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 90) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  type V1BlkioStatsError (line 96) | pub enum V1BlkioStatsError {
  type Error (line 110) | type Error = V1BlkioStatsError;
  type Stats (line 111) | type Stats = BlkioStats;
  method stats (line 113) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_blkio_weight (line 263) | fn test_set_blkio_weight() {
  function test_set_blkio_read_bps (line 278) | fn test_set_blkio_read_bps() {
  function test_set_blkio_write_bps (line 301) | fn test_set_blkio_write_bps() {
  function test_set_blkio_read_iops (line 324) | fn test_set_blkio_read_iops() {
  function test_set_blkio_write_iops (line 347) | fn test_set_blkio_write_iops() {
  function test_stat_throttling_policy (line 370) | fn test_stat_throttling_policy() -> Result<(), Box<dyn std::error::Error...

FILE: crates/libcgroups/src/v1/controller.rs
  type Controller (line 8) | pub(super) trait Controller {
    method add_task (line 13) | fn add_task(pid: Pid, cgroup_path: &Path) -> Result<(), Self::Error> {
    method apply (line 20) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result...
    method needs_to_handle (line 23) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'...

FILE: crates/libcgroups/src/v1/controller_type.rs
  type ControllerType (line 4) | pub enum ControllerType {
    method as_ref (line 41) | fn as_ref(&self) -> &str {
  method fmt (line 20) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  constant CONTROLLERS (line 59) | pub const CONTROLLERS: &[ControllerType] = &[

FILE: crates/libcgroups/src/v1/cpu.rs
  constant CGROUP_CPU_SHARES (line 9) | const CGROUP_CPU_SHARES: &str = "cpu.shares";
  constant CGROUP_CPU_QUOTA (line 10) | const CGROUP_CPU_QUOTA: &str = "cpu.cfs_quota_us";
  constant CGROUP_CPU_PERIOD (line 11) | const CGROUP_CPU_PERIOD: &str = "cpu.cfs_period_us";
  constant CGROUP_CPU_BURST (line 12) | const CGROUP_CPU_BURST: &str = "cpu.cfs_burst_us";
  constant CGROUP_CPU_RT_RUNTIME (line 13) | const CGROUP_CPU_RT_RUNTIME: &str = "cpu.rt_runtime_us";
  constant CGROUP_CPU_RT_PERIOD (line 14) | const CGROUP_CPU_RT_PERIOD: &str = "cpu.rt_period_us";
  constant CGROUP_CPU_STAT (line 15) | const CGROUP_CPU_STAT: &str = "cpu.stat";
  constant CGROUP_CPU_IDLE (line 16) | const CGROUP_CPU_IDLE: &str = "cpu.idle";
  type Cpu (line 18) | pub struct Cpu {}
    method apply (line 90) | fn apply(root_path: &Path, cpu: &LinuxCpu) -> Result<(), WrappedIoErro...
  type Error (line 21) | type Error = WrappedIoError;
  type Resource (line 22) | type Resource = LinuxCpu;
  method apply (line 24) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 34) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  type V1CpuStatsError (line 52) | pub enum V1CpuStatsError {
  type Error (line 60) | type Error = V1CpuStatsError;
  type Stats (line 61) | type Stats = CpuThrottling;
  method stats (line 63) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_shares (line 143) | fn test_set_shares() {
  function test_set_quota (line 160) | fn test_set_quota() {
  function test_set_period (line 176) | fn test_set_period() {
  function test_set_rt_runtime (line 192) | fn test_set_rt_runtime() {
  function test_set_cpu_idle (line 211) | fn test_set_cpu_idle() {
  function test_set_rt_period (line 238) | fn test_set_rt_period() {
  function test_stat_cpu_throttling (line 257) | fn test_stat_cpu_throttling() {
  function test_set_burst (line 277) | fn test_set_burst() {

FILE: crates/libcgroups/src/v1/cpuacct.rs
  constant CGROUP_CPUACCT_STAT (line 9) | const CGROUP_CPUACCT_STAT: &str = "cpuacct.stat";
  constant CGROUP_CPUACCT_USAGE (line 11) | const CGROUP_CPUACCT_USAGE: &str = "cpuacct.usage";
  constant CGROUP_CPUACCT_USAGE_ALL (line 13) | const CGROUP_CPUACCT_USAGE_ALL: &str = "cpuacct.usage_all";
  constant CGROUP_CPUACCT_PERCPU (line 15) | const CGROUP_CPUACCT_PERCPU: &str = "cpuacct.usage_percpu";
  type CpuAcct (line 17) | pub struct CpuAcct {}
    method get_total_cpu_usage (line 66) | fn get_total_cpu_usage(
    method get_per_core_usage (line 97) | fn get_per_core_usage(
  type Error (line 20) | type Error = WrappedIoError;
  type Resource (line 21) | type Resource = ();
  method apply (line 23) | fn apply(_controller_opt: &ControllerOpt, _cgroup_path: &Path) -> Result...
  method needs_to_handle (line 27) | fn needs_to_handle<'a>(_controller_opt: &'a ControllerOpt) -> Option<&'a...
  type V1CpuAcctStatsError (line 33) | pub enum V1CpuAcctStatsError {
  type Error (line 53) | type Error = V1CpuAcctStatsError;
  type Stats (line 54) | type Stats = CpuUsage;
  method stats (line 56) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, V1CpuAcctStatsError> {
  function setup_total_cpu (line 152) | fn setup_total_cpu(stat_content: &str, usage_content: &str) -> TempDir {
  function setup_per_core (line 163) | fn setup_per_core(percpu_content: &str, usage_all_content: &str) -> Temp...
  function test_add_task (line 175) | fn test_add_task() {
  function test_stat_total_cpu_usage (line 187) | fn test_stat_total_cpu_usage() {
  function test_stat_per_cpu_usage (line 201) | fn test_stat_per_cpu_usage() {

FILE: crates/libcgroups/src/v1/cpuset.rs
  constant CGROUP_CPUSET_CPUS (line 13) | const CGROUP_CPUSET_CPUS: &str = "cpuset.cpus";
  constant CGROUP_CPUSET_MEMS (line 14) | const CGROUP_CPUSET_MEMS: &str = "cpuset.mems";
  type V1CpuSetControllerError (line 17) | pub enum V1CpuSetControllerError {
  type CpuSet (line 31) | pub struct CpuSet {}
    method apply (line 69) | fn apply(cgroup_path: &Path, cpuset: &LinuxCpu) -> Result<(), V1CpuSet...
    method ensure_not_empty (line 83) | fn ensure_not_empty(
  type Error (line 34) | type Error = V1CpuSetControllerError;
  type Resource (line 35) | type Resource = LinuxCpu;
  method add_task (line 37) | fn add_task(pid: Pid, cgroup_path: &Path) -> Result<(), Self::Error> {
  method apply (line 47) | fn apply(controller_opt: &ControllerOpt, cgroup_path: &Path) -> Result<(...
  method needs_to_handle (line 57) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  function test_set_cpus (line 126) | fn test_set_cpus() {
  function test_set_mems (line 144) | fn test_set_mems() {

FILE: crates/libcgroups/src/v1/devices.rs
  type Devices (line 8) | pub struct Devices {}
    method apply_device (line 42) | fn apply_device(device: &LinuxDeviceCgroup, cgroup_root: &Path) -> Res...
  type Error (line 11) | type Error = WrappedIoError;
  type Resource (line 12) | type Resource = ();
  method apply (line 14) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 36) | fn needs_to_handle<'a>(_controller_opt: &'a ControllerOpt) -> Option<&'a...
  function test_set_default_devices (line 64) | fn test_set_default_devices() {
  function test_set_mock_devices (line 90) | fn test_set_mock_devices() {

FILE: crates/libcgroups/src/v1/freezer.rs
  constant CGROUP_FREEZER_STATE (line 9) | const CGROUP_FREEZER_STATE: &str = "freezer.state";
  constant FREEZER_STATE_THAWED (line 10) | const FREEZER_STATE_THAWED: &str = "THAWED";
  constant FREEZER_STATE_FROZEN (line 11) | const FREEZER_STATE_FROZEN: &str = "FROZEN";
  constant FREEZER_STATE_FREEZING (line 12) | const FREEZER_STATE_FREEZING: &str = "FREEZING";
  type V1FreezerControllerError (line 15) | pub enum V1FreezerControllerError {
  type Freezer (line 24) | pub struct Freezer {}
    method apply (line 47) | fn apply(
    method read_freezer_state (line 117) | fn read_freezer_state(cgroup_root: &Path) -> Result<String, WrappedIoE...
  type Error (line 27) | type Error = V1FreezerControllerError;
  type Resource (line 28) | type Resource = FreezerState;
  method apply (line 30) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 41) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  function test_set_freezer_state (line 141) | fn test_set_freezer_state() {
  function test_add_and_apply (line 179) | fn test_add_and_apply() {

FILE: crates/libcgroups/src/v1/hugetlb.rs
  type V1HugeTlbControllerError (line 14) | pub enum V1HugeTlbControllerError {
  type HugeTlb (line 24) | pub struct HugeTlb {}
    method apply (line 84) | fn apply(
    method is_power_of_two (line 125) | fn is_power_of_two(number: u64) -> bool {
    method stats_for_page_size (line 129) | fn stats_for_page_size(
  type Error (line 27) | type Error = V1HugeTlbControllerError;
  type Resource (line 28) | type Resource = Vec<LinuxHugepageLimit>;
  method apply (line 30) | fn apply(
  method needs_to_handle (line 45) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  type V1HugeTlbStatsError (line 57) | pub enum V1HugeTlbStatsError {
  type Error (line 67) | type Error = V1HugeTlbStatsError;
  type Stats (line 68) | type Stats = HashMap<String, HugeTlbStats>;
  method stats (line 70) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_hugetlb (line 165) | fn test_set_hugetlb() {
  function test_set_rsvd_hugetlb (line 183) | fn test_set_rsvd_hugetlb() {
  function test_set_hugetlb_with_invalid_page_size (line 209) | fn test_set_hugetlb_with_invalid_page_size() {
  function test_stat_hugetlb (line 251) | fn test_stat_hugetlb() {
  function test_stat_rsvd_hugetlb (line 269) | fn test_stat_rsvd_hugetlb() {

FILE: crates/libcgroups/src/v1/manager.rs
  type Manager (line 33) | pub struct Manager {
    method new (line 87) | pub fn new(cgroup_path: &Path) -> Result<Self, V1ManagerError> {
    method get_subsystem_path (line 100) | fn get_subsystem_path(
    method get_required_controllers (line 125) | fn get_required_controllers(
    method any (line 163) | pub fn any(self) -> AnyCgroupManager {
  type V1ManagerError (line 38) | pub enum V1ManagerError {
  type Error (line 169) | type Error = V1ManagerError;
  method get_all_pids (line 171) | fn get_all_pids(&self) -> Result<Vec<Pid>, Self::Error> {
  method add_task (line 180) | fn add_task(&self, pid: Pid) -> Result<(), Self::Error> {
  method apply (line 201) | fn apply(&self, controller_opt: &ControllerOpt) -> Result<(), Self::Erro...
  method remove (line 224) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 246) | fn freeze(&self, state: FreezerState) -> Result<(), Self::Error> {
  method stats (line 261) | fn stats(&self) -> Result<Stats, Self::Error> {

FILE: crates/libcgroups/src/v1/memory.rs
  constant CGROUP_MEMORY_SWAP_LIMIT (line 18) | const CGROUP_MEMORY_SWAP_LIMIT: &str = "memory.memsw.limit_in_bytes";
  constant CGROUP_MEMORY_LIMIT (line 19) | const CGROUP_MEMORY_LIMIT: &str = "memory.limit_in_bytes";
  constant CGROUP_MEMORY_USAGE (line 20) | const CGROUP_MEMORY_USAGE: &str = "memory.usage_in_bytes";
  constant CGROUP_MEMORY_MAX_USAGE (line 21) | const CGROUP_MEMORY_MAX_USAGE: &str = "memory.max_usage_in_bytes";
  constant CGROUP_MEMORY_SWAPPINESS (line 22) | const CGROUP_MEMORY_SWAPPINESS: &str = "memory.swappiness";
  constant CGROUP_MEMORY_RESERVATION (line 23) | const CGROUP_MEMORY_RESERVATION: &str = "memory.soft_limit_in_bytes";
  constant CGROUP_MEMORY_OOM_CONTROL (line 24) | const CGROUP_MEMORY_OOM_CONTROL: &str = "memory.oom_control";
  constant CGROUP_KERNEL_MEMORY_LIMIT (line 26) | const CGROUP_KERNEL_MEMORY_LIMIT: &str = "memory.kmem.limit_in_bytes";
  constant CGROUP_KERNEL_TCP_MEMORY_LIMIT (line 27) | const CGROUP_KERNEL_TCP_MEMORY_LIMIT: &str = "memory.kmem.tcp.limit_in_b...
  constant MEMORY_STAT (line 30) | const MEMORY_STAT: &str = "memory.stat";
  constant MEMORY_USE_HIERARCHY (line 32) | const MEMORY_USE_HIERARCHY: &str = "memory.use_hierarchy";
  constant MEMORY_PREFIX (line 34) | const MEMORY_PREFIX: &str = "memory";
  constant MEMORY_AND_SWAP_PREFIX (line 36) | const MEMORY_AND_SWAP_PREFIX: &str = "memory.memsw";
  constant MEMORY_KERNEL_PREFIX (line 38) | const MEMORY_KERNEL_PREFIX: &str = "memory.kmem";
  constant MEMORY_KERNEL_TCP_PREFIX (line 40) | const MEMORY_KERNEL_TCP_PREFIX: &str = "memory.kmem.tcp";
  constant MEMORY_USAGE_IN_BYTES (line 42) | const MEMORY_USAGE_IN_BYTES: &str = ".usage_in_bytes";
  constant MEMORY_MAX_USAGE_IN_BYTES (line 44) | const MEMORY_MAX_USAGE_IN_BYTES: &str = ".max_usage_in_bytes";
  constant MEMORY_LIMIT_IN_BYTES (line 46) | const MEMORY_LIMIT_IN_BYTES: &str = ".limit_in_bytes";
  constant MEMORY_FAIL_COUNT (line 48) | const MEMORY_FAIL_COUNT: &str = ".failcnt";
  type MalformedThing (line 51) | pub enum MalformedThing {
  method fmt (line 58) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type V1MemoryControllerError (line 68) | pub enum V1MemoryControllerError {
  type Memory (line 90) | pub struct Memory {}
    method get_memory_data (line 185) | fn get_memory_data(
    method set_oom_control (line 207) | fn set_oom_control(cgroup_root: &Path, disable_oom_killer: bool) -> Re...
    method hierarchy_enabled (line 215) | fn hierarchy_enabled(cgroup_path: &Path) -> Result<bool, WrappedIoErro...
    method get_stat_data (line 223) | fn get_stat_data(cgroup_path: &Path) -> Result<HashMap<String, u64>, P...
    method get_memory_usage (line 227) | fn get_memory_usage(cgroup_root: &Path) -> Result<u64, V1MemoryControl...
    method get_memory_max_usage (line 256) | fn get_memory_max_usage(cgroup_root: &Path) -> Result<u64, V1MemoryCon...
    method get_memory_limit (line 285) | fn get_memory_limit(cgroup_root: &Path) -> Result<i64, V1MemoryControl...
    method set (line 314) | fn set<T: ToString>(val: T, path: &Path) -> Result<(), WrappedIoError> {
    method set_memory (line 327) | fn set_memory(val: i64, cgroup_root: &Path) -> Result<(), V1MemoryCont...
    method set_swap (line 356) | fn set_swap(swap: i64, cgroup_root: &Path) -> Result<(), V1MemoryContr...
    method set_memory_and_swap (line 365) | fn set_memory_and_swap(
    method apply (line 385) | fn apply(resource: &LinuxMemory, cgroup_root: &Path) -> Result<(), V1M...
  type Error (line 93) | type Error = V1MemoryControllerError;
  type Resource (line 94) | type Resource = LinuxMemory;
  method apply (line 96) | fn apply(
  method needs_to_handle (line 147) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  type V1MemoryStatsError (line 152) | pub enum V1MemoryStatsError {
  type Error (line 160) | type Error = V1MemoryStatsError;
  type Stats (line 161) | type Stats = MemoryStats;
  method stats (line 163) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_memory (line 422) | fn test_set_memory() {
  function test_disable_oom_kill (line 436) | fn test_disable_oom_kill() {
  function pass_set_memory_if_limit_is_zero (line 452) | fn pass_set_memory_if_limit_is_zero() {
  function test_set_swap (line 465) | fn test_set_swap() {
  function test_set_memory_and_swap (line 476) | fn test_set_memory_and_swap() {
  function test_stat_memory_data (line 648) | fn test_stat_memory_data() {
  function test_stat_hierarchy_enabled (line 687) | fn test_stat_hierarchy_enabled() {
  function test_stat_hierarchy_disabled (line 696) | fn test_stat_hierarchy_disabled() {
  function test_stat_memory_stats (line 705) | fn test_stat_memory_stats() {

FILE: crates/libcgroups/src/v1/network_classifier.rs
  type NetworkClassifier (line 8) | pub struct NetworkClassifier {}
    method apply (line 30) | fn apply(root_path: &Path, network: &LinuxNetwork) -> Result<(), Wrapp...
  type Error (line 11) | type Error = WrappedIoError;
  type Resource (line 12) | type Resource = LinuxNetwork;
  method apply (line 14) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 24) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  function test_apply_network_classifier (line 47) | fn test_apply_network_classifier() {

FILE: crates/libcgroups/src/v1/network_priority.rs
  type NetworkPriority (line 8) | pub struct NetworkPriority {}
    method apply (line 30) | fn apply(root_path: &Path, network: &LinuxNetwork) -> Result<(), Wrapp...
  type Error (line 11) | type Error = WrappedIoError;
  type Resource (line 12) | type Resource = LinuxNetwork;
  method apply (line 14) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 24) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  function test_apply_network_priorities (line 48) | fn test_apply_network_priorities() {

FILE: crates/libcgroups/src/v1/perf_event.rs
  type PerfEvent (line 6) | pub struct PerfEvent {}
  type Error (line 9) | type Error = WrappedIoError;
  type Resource (line 10) | type Resource = ();
  method apply (line 12) | fn apply(_controller_opt: &ControllerOpt, _cgroup_root: &Path) -> Result...
  method needs_to_handle (line 16) | fn needs_to_handle<'a>(_controller_opt: &'a ControllerOpt) -> Option<&'a...
  function test_add_task (line 32) | fn test_add_task() {

FILE: crates/libcgroups/src/v1/pids.rs
  constant CGROUP_PIDS_MAX (line 10) | const CGROUP_PIDS_MAX: &str = "pids.max";
  type Pids (line 12) | pub struct Pids {}
    method apply (line 43) | fn apply(root_path: &Path, pids: &LinuxPids) -> Result<(), WrappedIoEr...
  type Error (line 15) | type Error = WrappedIoError;
  type Resource (line 16) | type Resource = LinuxPids;
  method apply (line 18) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  method needs_to_handle (line 28) | fn needs_to_handle<'a>(controller_opt: &'a ControllerOpt) -> Option<&'a ...
  type Error (line 34) | type Error = PidStatsError;
  type Stats (line 35) | type Stats = PidStats;
  method stats (line 37) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  constant CGROUP_PIDS_CURRENT (line 63) | const CGROUP_PIDS_CURRENT: &str = "pids.current";
  function test_set_pids (line 66) | fn test_set_pids() {
  function test_set_pids_max (line 79) | fn test_set_pids_max() {
  function test_stat_pids (line 93) | fn test_stat_pids() {
  function test_stat_pids_max (line 105) | fn test_stat_pids_max() {

FILE: crates/libcgroups/src/v1/util.rs
  type V1MountPointError (line 14) | pub enum V1MountPointError {
  function list_subsystem_mount_points (line 27) | pub fn list_subsystem_mount_points() -> Result<Vec<PathBuf>, V1MountPoin...
  function list_supported_mount_points (line 51) | pub fn list_supported_mount_points() -> Result<HashMap<ControllerType, P...
  function get_subsystem_mount_point (line 64) | pub fn get_subsystem_mount_point(subsystem: &ControllerType) -> Result<P...

FILE: crates/libcgroups/src/v2/controller.rs
  type Controller (line 5) | pub(super) trait Controller {
    method apply (line 8) | fn apply(controller_opt: &ControllerOpt, cgroup_path: &Path) -> Result...

FILE: crates/libcgroups/src/v2/controller_type.rs
  type ControllerType (line 4) | pub enum ControllerType {
  method fmt (line 14) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  constant CONTROLLER_TYPES (line 28) | pub const CONTROLLER_TYPES: &[ControllerType] = &[
  type PseudoControllerType (line 38) | pub enum PseudoControllerType {
  method fmt (line 45) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  constant PSEUDO_CONTROLLER_TYPES (line 56) | pub const PSEUDO_CONTROLLER_TYPES: &[PseudoControllerType] = &[

FILE: crates/libcgroups/src/v2/cpu.rs
  constant CGROUP_CPU_WEIGHT (line 10) | const CGROUP_CPU_WEIGHT: &str = "cpu.weight";
  constant CGROUP_CPU_MAX (line 11) | const CGROUP_CPU_MAX: &str = "cpu.max";
  constant CGROUP_CPU_BURST (line 12) | const CGROUP_CPU_BURST: &str = "cpu.max.burst";
  constant CGROUP_CPU_IDLE (line 13) | const CGROUP_CPU_IDLE: &str = "cpu.idle";
  constant UNRESTRICTED_QUOTA (line 14) | const UNRESTRICTED_QUOTA: &str = "max";
  constant MAX_CPU_WEIGHT (line 15) | const MAX_CPU_WEIGHT: u64 = 10000;
  constant CPU_STAT (line 17) | const CPU_STAT: &str = "cpu.stat";
  constant CPU_PSI (line 18) | const CPU_PSI: &str = "cpu.pressure";
  type V2CpuControllerError (line 21) | pub enum V2CpuControllerError {
  type Cpu (line 28) | pub struct Cpu {}
    method apply (line 87) | fn apply(path: &Path, cpu: &LinuxCpu) -> Result<(), V2CpuControllerErr...
    method convert_shares_to_cgroup2 (line 144) | fn convert_shares_to_cgroup2(shares: u64) -> u64 {
    method is_realtime_requested (line 167) | fn is_realtime_requested(cpu: &LinuxCpu) -> bool {
    method create_period_only_value (line 179) | fn create_period_only_value(
  type Error (line 31) | type Error = V2CpuControllerError;
  method apply (line 33) | fn apply(controller_opt: &ControllerOpt, path: &Path) -> Result<(), Self...
  type V2CpuStatsError (line 43) | pub enum V2CpuStatsError {
  type Error (line 53) | type Error = V2CpuStatsError;
  type Stats (line 54) | type Stats = CpuStats;
  method stats (line 56) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_valid_shares (line 202) | fn test_set_valid_shares() {
  function test_set_cpu_idle (line 219) | fn test_set_cpu_idle() {
  function test_set_positive_quota (line 246) | fn test_set_positive_quota() {
  function test_set_negative_quota (line 262) | fn test_set_negative_quota() {
  function test_set_positive_period (line 277) | fn test_set_positive_period() {
  function test_set_quota_and_period (line 295) | fn test_set_quota_and_period() {
  function test_realtime_runtime_not_supported (line 316) | fn test_realtime_runtime_not_supported() {
  function test_realtime_period_not_supported (line 335) | fn test_realtime_period_not_supported() {
  function test_stat_usage (line 354) | fn test_stat_usage() {
  function test_burst (line 389) | fn test_burst() {
  function test_cgroupsv2_but_runtime_set_to_zero (line 401) | fn test_cgroupsv2_but_runtime_set_to_zero() {
  function test_cgroupsv2_but_period_set_to_zero (line 417) | fn test_cgroupsv2_but_period_set_to_zero() {
  function test_cgroupsv2_but_period_and_runtime_set_to_zero (line 433) | fn test_cgroupsv2_but_period_and_runtime_set_to_zero() {

FILE: crates/libcgroups/src/v2/cpuset.rs
  constant CGROUP_CPUSET_CPUS (line 8) | const CGROUP_CPUSET_CPUS: &str = "cpuset.cpus";
  constant CGROUP_CPUSET_MEMS (line 9) | const CGROUP_CPUSET_MEMS: &str = "cpuset.mems";
  type CpuSet (line 11) | pub struct CpuSet {}
    method apply (line 26) | fn apply(path: &Path, cpuset: &LinuxCpu) -> Result<(), WrappedIoError> {
  type Error (line 14) | type Error = WrappedIoError;
  method apply (line 16) | fn apply(controller_opt: &ControllerOpt, cgroup_path: &Path) -> Result<(...
  function test_set_cpus (line 49) | fn test_set_cpus() {
  function test_set_mems (line 67) | fn test_set_mems() {

FILE: crates/libcgroups/src/v2/devices/bpf.rs
  type ProgramInfo (line 2) | pub struct ProgramInfo {
  type BpfError (line 8) | pub enum BpfError {
  function load (line 40) | pub fn load(license: &str, insns: &[u8]) -> Result<RawFd, super::BpfErro...
  function query (line 69) | pub fn query(cgroup_fd: RawFd) -> Result<Vec<ProgramInfo>, super::BpfErr...
  function detach2 (line 120) | pub fn detach2(prog_fd: RawFd, cgroup_fd: RawFd) -> Result<(), super::Bp...
  function attach (line 129) | pub fn attach(prog_fd: RawFd, cgroup_fd: RawFd) -> Result<(), super::Bpf...
  function bump_memlock_rlimit (line 140) | pub fn bump_memlock_rlimit() -> Result<(), super::BpfError> {
  function test_bpf_load (line 166) | fn test_bpf_load() {
  function test_bpf_attach (line 188) | fn test_bpf_attach() {
  function test_bpf_load_error (line 204) | fn test_bpf_load_error() {
  function test_bpf_query (line 226) | fn test_bpf_query() {
  function test_bpf_query_recoverable_error (line 272) | fn test_bpf_query_recoverable_error() {
  function test_bpf_query_other_error (line 318) | fn test_bpf_query_other_error() {
  function test_bpf_detach2 (line 347) | fn test_bpf_detach2() {
  function test_bpf_detach2_error (line 363) | fn test_bpf_detach2_error() {
  function test_bump_memlock_rlimit (line 379) | fn test_bump_memlock_rlimit() {
  function test_bump_memlock_rlimit_error (line 395) | fn test_bump_memlock_rlimit_error() {

FILE: crates/libcgroups/src/v2/devices/controller.rs
  constant LICENSE (line 18) | const LICENSE: &str = "Apache";
  type Devices (line 20) | pub struct Devices {}
    method apply_devices (line 48) | pub fn apply_devices(
  type DevicesControllerError (line 23) | pub enum DevicesControllerError {
  type Error (line 33) | type Error = DevicesControllerError;
  method apply (line 35) | fn apply(
  function test_apply_devices (line 128) | fn test_apply_devices() {
  function test_existing_programs (line 157) | fn test_existing_programs() {

FILE: crates/libcgroups/src/v2/devices/emulator.rs
  type Emulator (line 17) | pub struct Emulator {
    method with_default_allow (line 23) | pub fn with_default_allow(default_allow: bool) -> Self {
    method add_rules (line 30) | pub fn add_rules(&mut self, rules: &[LinuxDeviceCgroup]) {
    method add_rule (line 36) | pub fn add_rule(&mut self, rule: &LinuxDeviceCgroup) {
  function test_with_default_allow (line 61) | fn test_with_default_allow() {
  function test_type_a_rule (line 71) | fn test_type_a_rule() {
  function test_add_empty_rule (line 88) | fn test_add_empty_rule() {
  function test_add_some_rule (line 102) | fn test_add_some_rule() {

FILE: crates/libcgroups/src/v2/devices/mocks.rs
  type __rlimit_resource_t (line 9) | pub type __rlimit_resource_t = libc::c_int;
  type __rlimit_resource_t (line 13) | pub type __rlimit_resource_t = libc::__rlimit_resource_t;
  function setrlimit (line 15) | pub fn setrlimit(_resource: __rlimit_resource_t, _rlim: *const libc::rli...
  function bpf_prog_load (line 22) | pub fn bpf_prog_load(
  function bpf_prog_query (line 33) | pub fn bpf_prog_query(
  function bpf_prog_get_fd_by_id (line 44) | pub fn bpf_prog_get_fd_by_id(_id: libbpf_sys::__u32) -> ::std::os::raw::...
  function bpf_prog_detach2 (line 48) | pub fn bpf_prog_detach2(
  function bpf_prog_attach (line 56) | pub fn bpf_prog_attach(

FILE: crates/libcgroups/src/v2/devices/program.rs
  type Program (line 5) | pub struct Program {
    method from_rules (line 22) | pub fn from_rules(
    method bytecodes (line 38) | pub fn bytecodes(&self) -> &[u8] {
    method finalize (line 42) | fn finalize(&mut self, default_allow: bool) {
    method init (line 62) | fn init(&mut self) {
    method add_rule (line 104) | fn add_rule(&mut self, rule: &LinuxDeviceCgroup) -> Result<(), Program...
    method dump (line 193) | pub fn dump(&self) {
    method execute (line 197) | pub fn execute(
  type ProgramError (line 10) | pub enum ProgramError {
  function bpf_dev_type (line 211) | fn bpf_dev_type(typ: LinuxDeviceType) -> Result<u32, ProgramError> {
  function bpf_access (line 222) | fn bpf_access(access: String) -> Result<u32, ProgramError> {
  function bpf_cgroup_dev_ctx (line 236) | fn bpf_cgroup_dev_ctx(
  function build_bpf_program (line 265) | fn build_bpf_program(rules: &Option<Vec<LinuxDeviceCgroup>>) -> Result<P...
  function test_devices_allow_single (line 275) | fn test_devices_allow_single() {
  function test_devices_deny_all (line 321) | fn test_devices_deny_all() {
  function test_devices_allow_all (line 348) | fn test_devices_allow_all() {
  function test_devices_allow_wildcard (line 383) | fn test_devices_allow_wildcard() {
  function test_devices_allow_and_deny (line 424) | fn test_devices_allow_and_deny() {

FILE: crates/libcgroups/src/v2/freezer.rs
  constant CGROUP_FREEZE (line 11) | const CGROUP_FREEZE: &str = "cgroup.freeze";
  constant CGROUP_EVENTS (line 12) | const CGROUP_EVENTS: &str = "cgroup.events";
  type V2FreezerError (line 15) | pub enum V2FreezerError {
  type Freezer (line 33) | pub struct Freezer {}
    method apply (line 48) | fn apply(freezer_state: FreezerState, path: &Path) -> Result<(), V2Fre...
    method read_freezer_state (line 83) | fn read_freezer_state(path: &Path) -> Result<FreezerState, V2FreezerEr...
    method wait_frozen (line 105) | fn wait_frozen(path: &Path) -> Result<FreezerState, V2FreezerError> {
  type Error (line 36) | type Error = V2FreezerError;
  method apply (line 38) | fn apply(controller_opt: &ControllerOpt, cgroup_path: &Path) -> Result<(...
  function test_set_freezer_state (line 154) | fn test_set_freezer_state() {
  function test_set_freezer_state_error (line 201) | fn test_set_freezer_state_error() {

FILE: crates/libcgroups/src/v2/hugetlb.rs
  type V2HugeTlbControllerError (line 16) | pub enum V2HugeTlbControllerError {
  type HugeTlb (line 26) | pub struct HugeTlb {}
    method apply (line 75) | fn apply(
    method is_power_of_two (line 113) | fn is_power_of_two(number: u64) -> bool {
    method stats_for_page_size (line 117) | fn stats_for_page_size(
  type Error (line 29) | type Error = V2HugeTlbControllerError;
  method apply (line 31) | fn apply(
  type V2HugeTlbStatsError (line 46) | pub enum V2HugeTlbStatsError {
  type Error (line 56) | type Error = V2HugeTlbStatsError;
  type Stats (line 57) | type Stats = HashMap<String, HugeTlbStats>;
  method stats (line 59) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_hugetlb (line 158) | fn test_set_hugetlb() {
  function test_set_hugetlb_with_invalid_page_size (line 175) | fn test_set_hugetlb_with_invalid_page_size() {
  function test_set_rsvd_hugetlb (line 192) | fn test_set_rsvd_hugetlb() {
  function test_stat_hugetbl (line 241) | fn test_stat_hugetbl() {
  function test_stat_rsvd_hugetbl (line 257) | fn test_stat_rsvd_hugetbl() {

FILE: crates/libcgroups/src/v2/io.rs
  constant CGROUP_BFQ_IO_WEIGHT (line 13) | const CGROUP_BFQ_IO_WEIGHT: &str = "io.bfq.weight";
  constant CGROUP_IO_WEIGHT (line 14) | const CGROUP_IO_WEIGHT: &str = "io.weight";
  constant CGROUP_IO_STAT (line 15) | const CGROUP_IO_STAT: &str = "io.stat";
  constant CGROUP_IO_PSI (line 16) | const CGROUP_IO_PSI: &str = "io.pressure";
  type V2IoControllerError (line 19) | pub enum V2IoControllerError {
  type Io (line 26) | pub struct Io {}
    method convert_cfq_io_weight_to_bfq (line 111) | fn convert_cfq_io_weight_to_bfq(v: u16) -> u16 {
    method io_max_path (line 118) | fn io_max_path(path: &Path) -> PathBuf {
    method apply (line 123) | fn apply(root_path: &Path, blkio: &LinuxBlockIo) -> Result<(), V2IoCon...
  type Error (line 29) | type Error = V2IoControllerError;
  method apply (line 31) | fn apply(controller_opt: &ControllerOpt, cgroup_root: &Path) -> Result<(...
  type V2IoStatsError (line 41) | pub enum V2IoStatsError {
  type Error (line 53) | type Error = V2IoStatsError;
  type Stats (line 54) | type Stats = BlkioStats;
  method stats (line 56) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_io_read_bps (line 206) | fn test_set_io_read_bps() {
  function test_set_io_write_bps (line 228) | fn test_set_io_write_bps() {
  function test_set_io_read_iops (line 250) | fn test_set_io_read_iops() {
  function test_set_io_write_iops (line 272) | fn test_set_io_write_iops() {
  function test_set_ioweight_device (line 294) | fn test_set_ioweight_device() {
  function test_set_ioweight (line 317) | fn test_set_ioweight() {
  function test_stat_io (line 348) | fn test_stat_io() {

FILE: crates/libcgroups/src/v2/manager.rs
  constant CGROUP_KILL (line 30) | pub const CGROUP_KILL: &str = "cgroup.kill";
  type V2ManagerError (line 33) | pub enum V2ManagerError {
  type Manager (line 76) | pub struct Manager {
    method new (line 85) | pub fn new(root_path: PathBuf, cgroup_path: PathBuf) -> Result<Self, V...
    method create_unified_cgroup (line 96) | fn create_unified_cgroup(&self, pid: Pid) -> Result<(), V2ManagerError> {
    method write_controllers (line 132) | fn write_controllers(path: &Path, controllers: &[String]) -> Result<()...
    method any (line 140) | pub fn any(self) -> AnyCgroupManager {
  type Error (line 146) | type Error = V2ManagerError;
  method add_task (line 148) | fn add_task(&self, pid: Pid) -> Result<(), Self::Error> {
  method apply (line 157) | fn apply(&self, controller_opt: &ControllerOpt) -> Result<(), Self::Erro...
  method remove (line 185) | fn remove(&self) -> Result<(), Self::Error> {
  method freeze (line 210) | fn freeze(&self, state: FreezerState) -> Result<(), Self::Error> {
  method stats (line 220) | fn stats(&self) -> Result<Stats, Self::Error> {
  method get_all_pids (line 239) | fn get_all_pids(&self) -> Result<Vec<Pid>, Self::Error> {

FILE: crates/libcgroups/src/v2/memory.rs
  constant CGROUP_MEMORY_SWAP (line 9) | const CGROUP_MEMORY_SWAP: &str = "memory.swap.max";
  constant CGROUP_MEMORY_MAX (line 10) | const CGROUP_MEMORY_MAX: &str = "memory.max";
  constant CGROUP_MEMORY_LOW (line 11) | const CGROUP_MEMORY_LOW: &str = "memory.low";
  constant MEMORY_STAT (line 12) | const MEMORY_STAT: &str = "memory.stat";
  constant MEMORY_PSI (line 13) | const MEMORY_PSI: &str = "memory.pressure";
  type V2MemoryControllerError (line 16) | pub enum V2MemoryControllerError {
  type Memory (line 31) | pub struct Memory {}
    method get_memory_data (line 71) | fn get_memory_data(
    method set (line 101) | fn set<P: AsRef<Path>>(path: P, val: i64) -> Result<(), WrappedIoError> {
    method apply (line 111) | fn apply(path: &Path, memory: &LinuxMemory) -> Result<(), V2MemoryCont...
  type Error (line 34) | type Error = V2MemoryControllerError;
  method apply (line 36) | fn apply(controller_opt: &ControllerOpt, cgroup_path: &Path) -> Result<(...
  type V2MemoryStatsError (line 45) | pub enum V2MemoryStatsError {
  type Error (line 53) | type Error = V2MemoryStatsError;
  type Stats (line 54) | type Stats = MemoryStats;
  method stats (line 56) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_memory (line 177) | fn test_set_memory() {
  function test_set_memory_unlimited (line 211) | fn test_set_memory_unlimited() {
  function test_err_swap_no_memory (line 232) | fn test_err_swap_no_memory() {
  function test_err_bad_limit (line 247) | fn test_err_bad_limit() {
  function test_err_bad_swap (line 262) | fn test_err_bad_swap() {
  function test_get_memory_data (line 365) | fn test_get_memory_data() {
  function test_get_memory_data_with_peak (line 385) | fn test_get_memory_data_with_peak() {

FILE: crates/libcgroups/src/v2/pids.rs
  type Pids (line 9) | pub struct Pids {}
    method apply (line 36) | fn apply(root_path: &Path, pids: &LinuxPids) -> Result<(), WrappedIoEr...
  type Error (line 12) | type Error = WrappedIoError;
  method apply (line 14) | fn apply(
  type Error (line 27) | type Error = PidStatsError;
  type Stats (line 28) | type Stats = PidStats;
  method stats (line 30) | fn stats(cgroup_path: &Path) -> Result<Self::Stats, Self::Error> {
  function test_set_pids (line 54) | fn test_set_pids() {
  function test_set_pids_max (line 68) | fn test_set_pids_max() {

FILE: crates/libcgroups/src/v2/unified.rs
  type V2UnifiedError (line 8) | pub enum V2UnifiedError {
  type Unified (line 18) | pub struct Unified {}
    method apply (line 21) | pub fn apply(
    method apply_impl (line 33) | fn apply_impl(
  function test_set_unified (line 70) | fn test_set_unified() {
  function test_set_unified_failed_to_write_subsystem_not_enabled (line 109) | fn test_set_unified_failed_to_write_subsystem_not_enabled() {
  function test_set_unified_failed_to_write_subsystem_enabled (line 143) | fn test_set_unified_failed_to_write_subsystem_enabled() {

FILE: crates/libcgroups/src/v2/util.rs
  constant CGROUP_CONTROLLERS (line 12) | pub const CGROUP_CONTROLLERS: &str = "cgroup.controllers";
  constant CGROUP_SUBTREE_CONTROL (line 13) | pub const CGROUP_SUBTREE_CONTROL: &str = "cgroup.subtree_control";
  type V2UtilError (line 16) | pub enum V2UtilError {
  function get_unified_mount_point (line 32) | pub fn get_unified_mount_point() -> Result<PathBuf, V2UtilError> {
  function get_available_controllers (line 56) | pub fn get_available_controllers<P: AsRef<Path>>(

FILE: crates/libcontainer/src/apparmor.rs
  type AppArmorError (line 9) | pub enum AppArmorError {
  type Result (line 20) | type Result<T> = std::result::Result<T, AppArmorError>;
  constant ENABLED_PARAMETER_PATH (line 22) | const ENABLED_PARAMETER_PATH: &str = "/sys/module/apparmor/parameters/en...
  function is_enabled (line 25) | pub fn is_enabled() -> std::result::Result<bool, std::io::Error> {
  function apply_profile (line 31) | pub fn apply_profile(profile: &str) -> Result<()> {
  function activate_profile (line 43) | fn activate_profile(subpath: &Path, profile: &str) -> Result<()> {

FILE: crates/libcontainer/src/capabilities.rs
  function to_set (line 8) | fn to_set(caps: &Capabilities) -> CapsHashSet {
  type CapabilityExt (line 18) | pub trait CapabilityExt {
    method to_cap (line 20) | fn to_cap(&self) -> caps::Capability;
    method from_cap (line 22) | fn from_cap(c: CapsCapability) -> Self;
    method to_cap (line 27) | fn to_cap(&self) -> caps::Capability {
    method from_cap (line 74) | fn from_cap(c: CapsCapability) -> SpecCapability {
  function reset_effective (line 125) | pub fn reset_effective<S: Syscall + ?Sized>(syscall: &S) -> Result<(), S...
  function drop_privileges (line 134) | pub fn drop_privileges<S: Syscall + ?Sized>(
  function test_reset_effective (line 172) | fn test_reset_effective() {
  function test_convert_oci_spec_to_caps_type (line 185) | fn test_convert_oci_spec_to_caps_type() {
  function test_convert_caps_type_to_oci_spec (line 365) | fn test_convert_caps_type_to_oci_spec() {
  function test_drop_privileges (line 545) | fn test_drop_privileges() {

FILE: crates/libcontainer/src/channel.rs
  type ChannelError (line 11) | pub enum ChannelError {
  type Receiver (line 19) | pub struct Receiver<T> {
  type Sender (line 24) | pub struct Sender<T> {
  function send_iovec (line 33) | fn send_iovec(
  function send_slice_with_len (line 47) | fn send_slice_with_len(
  function send (line 66) | pub fn send(&mut self, object: T) -> Result<(), ChannelError> {
  function send_fds (line 73) | pub fn send_fds(&mut self, object: T, fds: &[RawFd]) -> Result<(), Chann...
  function close (line 80) | pub fn close(&self) -> Result<(), ChannelError> {
  function peek_size_iovec (line 89) | fn peek_size_iovec(&mut self) -> Result<u64, ChannelError> {
  function recv_into_iovec (line 105) | fn recv_into_iovec<F>(
  function recv_into_buf_with_len (line 143) | fn recv_into_buf_with_len<F>(&mut self) -> Result<(Vec<u8>, Option<F>), ...
  function recv (line 170) | pub fn recv(&mut self) -> Result<T, ChannelError> {
  function recv_with_fds (line 178) | pub fn recv_with_fds<F>(&mut self) -> Result<(T, Option<F>), ChannelError>
  function close (line 186) | pub fn close(&self) -> Result<(), ChannelError> {
  function channel (line 191) | pub fn channel<T>() -> Result<(Sender<T>, Receiver<T>), ChannelError>
  function unix_channel (line 208) | fn unix_channel() -> Result<(RawFd, RawFd), ChannelError> {

FILE: crates/libcontainer/src/config.rs
  type PersonalityDomain (line 10) | pub enum PersonalityDomain {
  type ConfigError (line 16) | pub enum ConfigError {
  type Result (line 41) | type Result<T> = std::result::Result<T, ConfigError>;
  constant YOUKI_CONFIG_NAME (line 43) | const YOUKI_CONFIG_NAME: &str = "youki_config.json";
  type YoukiConfig (line 49) | pub struct YoukiConfig {
    method from_spec (line 55) | pub fn from_spec(spec: &Spec, container_id: &str) -> Result<Self> {
    method save (line 68) | pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()> {
    method load (line 88) | pub fn load<P: AsRef<Path>>(path: P) -> Result<Self> {
  function test_config_from_spec (line 111) | fn test_config_from_spec() -> Result<()> {
  function test_config_save_and_load (line 125) | fn test_config_save_and_load() -> Result<()> {

FILE: crates/libcontainer/src/container/builder.rs
  type ContainerBuilder (line 11) | pub struct ContainerBuilder {
    method new (line 70) | pub fn new(container_id: String, syscall: SyscallType) -> Self {
    method validate_id (line 103) | pub fn validate_id(self) -> Result<Self, LibcontainerError> {
    method as_tenant (line 138) | pub fn as_tenant(self) -> TenantContainerBuilder {
    method as_init (line 158) | pub fn as_init<P: Into<PathBuf>>(self, bundle: P) -> InitContainerBuil...
    method with_root_path (line 175) | pub fn with_root_path<P: Into<PathBuf>>(mut self, path: P) -> Result<S...
    method with_pid_file (line 199) | pub fn with_pid_file<P: Into<PathBuf>>(
    method with_console_socket (line 228) | pub fn with_console_socket<P: Into<PathBuf>>(mut self, path: Option<P>...
    method with_preserved_fds (line 247) | pub fn with_preserved_fds(mut self, preserved_fds: i32) -> Self {
    method with_executor (line 266) | pub fn with_executor(mut self, executor: impl Executor + 'static) -> S...
    method with_stdin (line 289) | pub fn with_stdin(mut self, stdin: impl Into<OwnedFd>) -> Self {
    method with_stdout (line 312) | pub fn with_stdout(mut self, stdout: impl Into<OwnedFd>) -> Self {
    method with_stderr (line 335) | pub fn with_stderr(mut self, stderr: impl Into<OwnedFd>) -> Self {
  function test_failable_functions (line 353) | fn test_failable_functions() -> Result<()> {
  function test_validate_id (line 399) | fn test_validate_id() -> Result<()> {
  function test_stdios (line 420) | fn test_stdios() -> Result<()> {

FILE: crates/libcontainer/src/container/builder_impl.rs
  type ContainerBuilderImpl (line 22) | pub(super) struct ContainerBuilderImpl {
    method create (line 65) | pub(super) fn create(&mut self) -> Result<Pid, LibcontainerError> {
    method is_init_container (line 82) | fn is_init_container(&self) -> bool {
    method run_container (line 86) | fn run_container(&mut self) -> Result<Pid, LibcontainerError> {
    method cleanup_container (line 192) | fn cleanup_container(&self) -> Result<(), LibcontainerError> {

FILE: crates/libcontainer/src/container/container.rs
  type Container (line 17) | pub struct Container {
    method new (line 34) | pub fn new(
    method id (line 57) | pub fn id(&self) -> &str {
    method can_start (line 61) | pub fn can_start(&self) -> bool {
    method can_kill (line 65) | pub fn can_kill(&self) -> bool {
    method can_delete (line 69) | pub fn can_delete(&self) -> bool {
    method can_exec (line 73) | pub fn can_exec(&self) -> bool {
    method can_pause (line 77) | pub fn can_pause(&self) -> bool {
    method can_resume (line 81) | pub fn can_resume(&self) -> bool {
    method bundle (line 85) | pub fn bundle(&self) -> &PathBuf {
    method set_annotations (line 89) | pub fn set_annotations(&mut self, annotations: Option<HashMap<String, ...
    method pid (line 94) | pub fn pid(&self) -> Option<Pid> {
    method set_pid (line 98) | pub fn set_pid(&mut self, pid: i32) -> &mut Self {
    method created (line 103) | pub fn created(&self) -> Option<DateTime<Utc>> {
    method creator (line 107) | pub fn creator(&self) -> Option<OsString> {
    method set_creator (line 119) | pub fn set_creator(&mut self, uid: u32) -> &mut Self {
    method systemd (line 124) | pub fn systemd(&self) -> bool {
    method set_systemd (line 128) | pub fn set_systemd(&mut self, should_use: bool) -> &mut Self {
    method set_clean_up_intel_rdt_directory (line 133) | pub fn set_clean_up_intel_rdt_directory(&mut self, clean_up: bool) -> ...
    method clean_up_intel_rdt_subdirectory (line 138) | pub fn clean_up_intel_rdt_subdirectory(&self) -> Option<bool> {
    method status (line 142) | pub fn status(&self) -> ContainerStatus {
    method set_status (line 146) | pub fn set_status(&mut self, status: ContainerStatus) -> &mut Self {
    method refresh_status (line 158) | pub fn refresh_status(&mut self) -> Result<(), LibcontainerError> {
    method refresh_state (line 187) | pub fn refresh_state(&mut self) -> Result<&mut Self, LibcontainerError> {
    method load (line 194) | pub fn load(container_root: PathBuf) -> Result<Self, LibcontainerError> {
    method save (line 204) | pub fn save(&self) -> Result<(), LibcontainerError> {
    method spec (line 211) | pub fn spec(&self) -> Result<YoukiConfig, LibcontainerError> {
  method default (line 25) | fn default() -> Self {
  type CheckpointOptions (line 218) | pub struct CheckpointOptions {
  function test_get_set_pid (line 236) | fn test_get_set_pid() {
  function test_basic_getter (line 245) | fn test_basic_getter() -> Result<()> {
  function test_set_annotations (line 272) | fn test_set_annotations() {
  function test_get_set_systemd (line 286) | fn test_get_set_systemd() {
  function test_get_set_creator (line 296) | fn test_get_set_creator() {
  function test_refresh_load_save_state (line 305) | fn test_refresh_load_save_state() -> Result<()> {
  function test_get_spec (line 330) | fn test_get_spec() -> Result<()> {
  function test_get_set_refresh_status (line 348) | fn test_get_set_refresh_status() -> Result<()> {

FILE: crates/libcontainer/src/container/container_checkpoint.rs
  constant CRIU_CHECKPOINT_LOG_FILE (line 16) | const CRIU_CHECKPOINT_LOG_FILE: &str = "dump.log";
  constant DESCRIPTORS_JSON (line 17) | const DESCRIPTORS_JSON: &str = "descriptors.json";
  type CheckpointError (line 20) | pub enum CheckpointError {
  method checkpoint (line 26) | pub fn checkpoint(&mut self, opts: &CheckpointOptions) -> Result<(), Lib...

FILE: crates/libcontainer/src/container/container_criu.rs
  constant CRIU_VERSION_MINIMUM (line 11) | pub const CRIU_VERSION_MINIMUM: u32 = 31500;
  function compare_criu_version (line 13) | fn compare_criu_version(version: u32, min_version: u32) -> Result<(), Li...
  function check_criu_version (line 24) | pub fn check_criu_version(min_version: u32) -> Result<(), LibcontainerEr...
  function test_compare_criu_version_ok (line 40) | fn test_compare_criu_version_ok() {
  function test_compare_criu_version_too_low (line 47) | fn test_compare_criu_version_too_low() {

FILE: crates/libcontainer/src/container/container_delete.rs
  method delete (line 34) | pub fn delete(&mut self, force: bool) -> Result<(), LibcontainerError> {

FILE: crates/libcontainer/src/container/container_events.rs
  method events (line 30) | pub fn events(&mut self, interval: u32, stats: bool) -> Result<(), Libco...

FILE: crates/libcontainer/src/container/container_kill.rs
  method kill (line 30) | pub fn kill<S: Into<Signal>>(&mut self, signal: S, all: bool) -> Result<...
  method do_kill (line 48) | pub(crate) fn do_kill<S: Into<Signal>>(
  method kill_one_process (line 60) | fn kill_one_process<S: Into<Signal>>(&self, signal: S) -> Result<(), Lib...
  method kill_all_processes (line 100) | fn kill_all_processes<S: Into<Signal>>(&self, signal: S) -> Result<(), L...

FILE: crates/libcontainer/src/container/container_pause.rs
  method pause (line 27) | pub fn pause(&mut self) -> Result<(), LibcontainerError> {

FILE: crates/libcontainer/src/container/container_resume.rs
  method resume (line 27) | pub fn resume(&mut self) -> Result<(), LibcontainerError> {

FILE: crates/libcontainer/src/container/container_start.rs
  method start (line 28) | pub fn start(&mut self) -> Result<(), LibcontainerError> {

FILE: crates/libcontainer/src/container/init_builder.rs
  type InitContainerBuilder (line 19) | pub struct InitContainerBuilder {
    method new (line 31) | pub(super) fn new(builder: ContainerBuilder, bundle: PathBuf) -> Self {
    method with_systemd (line 43) | pub fn with_systemd(mut self, should_use: bool) -> Self {
    method as_sibling (line 50) | pub fn as_sibling(mut self, as_sibling: bool) -> Self {
    method with_detach (line 55) | pub fn with_detach(mut self, detached: bool) -> Self {
    method with_no_pivot (line 60) | pub fn with_no_pivot(mut self, no_pivot: bool) -> Self {
    method build (line 66) | pub fn build(self) -> Result<Container, LibcontainerError> {
    method create_container_dir (line 129) | fn create_container_dir(&self) -> Result<PathBuf, LibcontainerError> {
    method load_spec (line 150) | fn load_spec(&self) -> Result<Spec, LibcontainerError> {
    method validate_spec (line 163) | fn validate_spec(spec: &Spec) -> Result<(), LibcontainerError> {
    method create_container_state (line 223) | fn create_container_state(&self, container_dir: &Path) -> Result<Conta...

FILE: crates/libcontainer/src/container/state.rs
  type ContainerStatus (line 21) | pub enum ContainerStatus {
    method can_start (line 36) | pub fn can_start(&self) -> bool {
    method can_kill (line 40) | pub fn can_kill(&self) -> bool {
    method can_delete (line 48) | pub fn can_delete(&self) -> bool {
    method can_pause (line 52) | pub fn can_pause(&self) -> bool {
    method can_resume (line 56) | pub fn can_resume(&self) -> bool {
  method fmt (line 62) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type StateError (line 76) | pub enum StateError {
  type Result (line 94) | type Result<T> = std::result::Result<T, StateError>;
  type State (line 99) | pub struct State {
    constant STATE_FILE_PATH (line 127) | const STATE_FILE_PATH: &'static str = "state.json";
    method new (line 129) | pub fn new(
    method save (line 150) | pub fn save(&self, container_root: &Path) -> Result<()> {
    method load (line 197) | pub fn load(container_root: &Path) -> Result<Self> {
    method file_path (line 236) | pub fn file_path(container_root: &Path) -> PathBuf {
  type StateConversionError (line 243) | pub enum StateConversionError {
  type Error (line 255) | type Error = StateConversionError;
  method try_from (line 257) | fn try_from(state: &State) -> std::result::Result<Self, Self::Error> {
  type Error (line 279) | type Error = StateConversionError;
  method try_from (line 281) | fn try_from(status: ContainerStatus) -> std::result::Result<Self, Self::...
  type ContainerProcessState (line 300) | pub struct ContainerProcessState {
  function test_creating_status (line 320) | fn test_creating_status() {
  function test_create_status (line 330) | fn test_create_status() {
  function test_running_status (line 340) | fn test_running_status() {
  function test_stopped_status (line 350) | fn test_stopped_status() {
  function test_paused_status (line 360) | fn test_paused_status() {

FILE: crates/libcontainer/src/container/tenant_builder.rs
  constant NAMESPACE_TYPES (line 32) | const NAMESPACE_TYPES: &[&str] = &["ipc", "uts", "net", "pid", "mnt", "c...
  constant TENANT_NOTIFY (line 33) | const TENANT_NOTIFY: &str = "tenant-notify-";
  constant TENANT_TTY (line 34) | const TENANT_TTY: &str = "tenant-tty-";
  type TenantContainerBuilder (line 38) | pub struct TenantContainerBuilder {
    method new (line 132) | pub(super) fn new(builder: ContainerBuilder) -> Self {
    method with_env (line 150) | pub fn with_env(mut self, env: HashMap<String, String>) -> Self {
    method with_cwd (line 156) | pub fn with_cwd<P: Into<PathBuf>>(mut self, path: Option<P>) -> Self {
    method with_container_args (line 162) | pub fn with_container_args(mut self, args: Vec<String>) -> Self {
    method with_no_new_privs (line 167) | pub fn with_no_new_privs(mut self, no_new_privs: bool) -> Self {
    method with_capabilities (line 172) | pub fn with_capabilities(mut self, capabilities: Vec<String>) -> Self {
    method with_process (line 177) | pub fn with_process<P: Into<PathBuf>>(mut self, path: Option<P>) -> Se...
    method as_sibling (line 184) | pub fn as_sibling(mut self, as_sibling: bool) -> Self {
    method with_detach (line 189) | pub fn with_detach(mut self, detached: bool) -> Self {
    method with_additional_gids (line 194) | pub fn with_additional_gids(mut self, gids: Vec<u32>) -> Self {
    method with_user (line 199) | pub fn with_user(mut self, user: Option<u32>) -> Self {
    method with_group (line 204) | pub fn with_group(mut self, group: Option<u32>) -> Self {
    method build (line 210) | pub fn build(self) -> Result<Pid, LibcontainerError> {
    method lookup_container_dir (line 291) | fn lookup_container_dir(&self) -> Result<PathBuf, LibcontainerError> {
    method load_init_spec (line 301) | fn load_init_spec(&self, container: &Container) -> Result<Spec, Libcon...
    method validate_spec (line 315) | fn validate_spec(spec: &Spec) -> Result<(), LibcontainerError> {
    method load_container_state (line 420) | fn load_container_state(&self, container_dir: PathBuf) -> Result<Conta...
    method adapt_spec_for_tenant (line 430) | fn adapt_spec_for_tenant(
    method get_process (line 508) | fn get_process(&self, process: &Path) -> Result<Process, LibcontainerE...
    method get_working_dir (line 523) | fn get_working_dir(&self) -> Result<Option<PathBuf>, LibcontainerError> {
    method get_args (line 536) | fn get_args(&self) -> Result<Vec<String>, LibcontainerError> {
    method get_environment (line 549) | fn get_environment(&self, spec_env: Vec<String>) -> Vec<String> {
    method get_no_new_privileges (line 567) | fn get_no_new_privileges(&self) -> Option<bool> {
    method get_namespaces (line 571) | fn get_namespaces(
    method should_use_systemd (line 592) | fn should_use_systemd(&self, container: &Container) -> bool {
    method setup_notify_listener (line 596) | fn setup_notify_listener(container_dir: &Path) -> Result<PathBuf, Libc...
    method setup_tty_socket (line 603) | fn setup_tty_socket(&self, container_dir: &Path) -> Result<Option<Owne...
    method generate_name (line 618) | fn generate_name(dir: &Path, prefix: &str) -> String {
  function get_capabilities (line 56) | fn get_capabilities(
  function get_spec (line 638) | fn get_spec(caps: LinuxCapabilities) -> Spec {
  function cap_to_string (line 650) | fn cap_to_string(caps: &[Cap]) -> Vec<String> {
  function caps_to_spec_set (line 654) | fn caps_to_spec_set(caps: &[Cap]) -> Capabilities {
  function empty_caps (line 658) | fn empty_caps() -> LinuxCapabilities {
  function builder_with_env (line 669) | fn builder_with_env(env: &[(&str, &str)]) -> TenantContainerBuilder {
  function test_capabilities_no_existing (line 684) | fn test_capabilities_no_existing() -> Result<(), LibcontainerError> {
  function test_capabilities_with_existing (line 706) | fn test_capabilities_with_existing() -> Result<(), LibcontainerError> {
  function test_capabilities_with_existing_inherent (line 738) | fn test_capabilities_with_existing_inherent() -> Result<(), Libcontainer...
  function env_inherits_spec_vars (line 796) | fn env_inherits_spec_vars() {
  function builder_env_overrides_spec (line 805) | fn builder_env_overrides_spec() {
  function builder_env_adds_new_vars (line 815) | fn builder_env_adds_new_vars() {
  function empty_spec_env_uses_builder_env_only (line 824) | fn empty_spec_env_uses_builder_env_only() {
  function no_env_at_all (line 831) | fn no_env_at_all() {

FILE: crates/libcontainer/src/error.rs
  type MissingSpecError (line 4) | pub enum MissingSpecError {
  type LibcontainerError (line 16) | pub enum LibcontainerError {
  type ErrInvalidID (line 88) | pub enum ErrInvalidID {
  type ErrInvalidSpec (line 98) | pub enum ErrInvalidSpec {
  type CreateContainerError (line 110) | pub struct CreateContainerError(Box<LibcontainerError>, Option<Box<Libco...
    method new (line 113) | pub(crate) fn new(
    method fmt (line 122) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function test_create_container (line 138) | fn test_create_container() {
  function test_libcontainer_error_msg (line 159) | fn test_libcontainer_error_msg() {

FILE: crates/libcontainer/src/hooks.rs
  type HookError (line 15) | pub enum HookError {
  type Result (line 34) | type Result<T> = std::result::Result<T, HookError>;
  function run_hooks (line 36) | pub fn run_hooks(
  function is_command_in_path (line 174) | fn is_command_in_path(program: &str) -> bool {
  function test_run_hook (line 195) | fn test_run_hook() -> Result<()> {
  function test_run_hook_timeout (line 286) | fn test_run_hook_timeout() -> Result<()> {

FILE: crates/libcontainer/src/namespaces.rs
  type Result (line 20) | type Result<T> = std::result::Result<T, NamespaceError>;
  type NamespaceError (line 23) | pub enum NamespaceError {
  type Namespaces (line 45) | pub struct Namespaces {
    type Error (line 66) | type Error = NamespaceError;
    method try_from (line 68) | fn try_from(namespaces: Option<&Vec<LinuxNamespace>>) -> Result<Self> {
    method apply_namespaces (line 89) | pub fn apply_namespaces<F: Fn(CloneFlags) -> bool>(&self, filter: F) -...
    method unshare_or_setns (line 102) | pub fn unshare_or_setns(&self, namespace: &LinuxNamespace) -> Result<(...
    method get (line 133) | pub fn get(&self, k: LinuxNamespaceType) -> Result<Option<&LinuxNamesp...
  function get_clone_flag (line 50) | fn get_clone_flag(namespace_type: LinuxNamespaceType) -> Result<CloneFla...
  function gen_sample_linux_namespaces (line 146) | fn gen_sample_linux_namespaces() -> Vec<LinuxNamespace> {
  function test_apply_namespaces (line 175) | fn test_apply_namespaces() {

FILE: crates/libcontainer/src/network/address.rs
  type AddressMessageHandler (line 17) | pub struct AddressMessageHandler {
    method new (line 22) | pub fn new() -> Self {
    method with_index (line 26) | pub fn with_index(index: u32) -> Self {
  method default (line 34) | fn default() -> Self {
  type Response (line 40) | type Response = AddressMessage;
  method handle_payload (line 42) | fn handle_payload(
  type AddressClient (line 75) | pub struct AddressClient {
    method new (line 85) | pub fn new(client: ClientWrapper) -> Result<Self> {
    method get_by_index (line 98) | pub fn get_by_index(&mut self, index: u32) -> Result<Vec<AddressMessag...
    method add (line 123) | pub fn add(&mut self, index: u32, address: IpAddr, prefix_len: u8) -> ...
    method create_address_request (line 152) | fn create_address_request(
    method get_send_calls (line 191) | pub fn get_send_calls(
  function test_address_message_handler_success (line 212) | fn test_address_message_handler_success() {
  function test_address_message_handler_errorcode_zero (line 238) | fn test_address_message_handler_errorcode_zero() {
  function test_address_message_handler_error (line 254) | fn test_address_message_handler_error() {
  function test_address_message_handler_done (line 272) | fn test_address_message_handler_done() {
  function test_address_message_handler_unexpected (line 286) | fn test_address_message_handler_unexpected() {
  function test_address_client_new (line 298) | fn test_address_client_new() {
  function test_address_client_get_by_index_failure (line 305) | fn test_address_client_get_by_index_failure() {
  function test_address_client_get_by_index_without_response (line 317) | fn test_address_client_get_by_index_without_response() {
  function test_address_client_get_by_index_with_multiple_responses (line 328) | fn test_address_client_get_by_index_with_multiple_responses() {
  function test_address_client_get_by_index_success (line 367) | fn test_address_client_get_by_index_success() {
  function test_address_client_add_failure (line 402) | fn test_address_client_add_failure() {
  function test_address_client_add_success (line 414) | fn test_address_client_add_success() {
  function test_address_client_add_with_different_parameters (line 463) | fn test_address_client_add_with_different_parameters() {
  function test_create_address_request_ipv4 (line 554) | fn test_create_address_request_ipv4() {
  function test_create_address_request_ipv6 (line 569) | fn test_create_address_request_ipv6() {

FILE: crates/libcontainer/src/network/cidr.rs
  type CidrAddress (line 7) | pub struct CidrAddress {
    method from (line 13) | fn from(msg: &AddressMessage) -> Self {
  function parse_ip_address (line 37) | fn parse_ip_address(addr: &AddressMessage) -> Option<IpAddr> {
  function test_address_message_to_cidr (line 66) | fn test_address_message_to_cidr() {
  function test_parse_ip_address_with_local (line 83) | fn test_parse_ip_address_with_local() {
  function test_parse_ip_address_without_local (line 102) | fn test_parse_ip_address_without_local() {
  function test_parse_ip_address_ipv6_with_local (line 121) | fn test_parse_ip_address_ipv6_with_local() {
  function test_parse_ip_address_no_attributes (line 143) | fn test_parse_ip_address_no_attributes() {

FILE: crates/libcontainer/src/network/client.rs
  type NetlinkClient (line 13) | pub struct NetlinkClient {
    method new (line 23) | pub fn new() -> Result<Self> {
  method send (line 31) | fn send(&mut self, req: &NetlinkMessage<RouteNetlinkMessage>) -> Result<...
  method receive (line 38) | fn receive<T, H>(&mut self, handler: H) -> Result<T>
  method receive_multiple (line 68) | fn receive_multiple<T, H>(&mut self, handler: H) -> Result<Vec<T>>
  method send_and_receive (line 104) | fn send_and_receive<T, H>(
  method send_and_receive_multiple (line 116) | fn send_and_receive_multiple<T, H>(

FILE: crates/libcontainer/src/network/fake.rs
  type FakeResponse (line 10) | pub enum FakeResponse {
  type FakeNetlinkClient (line 21) | pub struct FakeNetlinkClient {
    method new (line 27) | pub fn new() -> Self {
    method set_failure (line 38) | pub fn set_failure(&mut self, error_message: String) {
    method set_expected_responses (line 48) | pub fn set_expected_responses(&mut self, responses: Vec<RouteNetlinkMe...
    method get_send_calls (line 56) | pub fn get_send_calls(&self) -> &[NetlinkMessage<RouteNetlinkMessage>] {
    method clear_send_calls (line 60) | pub fn clear_send_calls(&mut self) {
  method default (line 65) | fn default() -> Self {
  method send (line 70) | fn send(&mut self, req: &NetlinkMessage<RouteNetlinkMessage>) -> Result<...
  method receive (line 74) | fn receive<T, H>(&mut self, handler: H) -> Result<T>
  method receive_multiple (line 104) | fn receive_multiple<T, H>(&mut self, handler: H) -> Result<Vec<T>>
  method send_and_receive (line 134) | fn send_and_receive<T, H>(
  method send_and_receive_multiple (line 145) | fn send_and_receive_multiple<T, H>(

FILE: crates/libcontainer/src/network/link.rs
  type LinkMessageHandler (line 17) | pub struct LinkMessageHandler;
  type Response (line 20) | type Response = LinkMessage;
  method handle_payload (line 22) | fn handle_payload(
  type LinkClient (line 50) | pub struct LinkClient {
    method new (line 60) | pub fn new(client: ClientWrapper) -> Result<Self> {
    method get_by_name (line 73) | pub fn get_by_name(&mut self, name: &str) -> Result<LinkMessage> {
    method set_up (line 95) | pub fn set_up(&mut self, index: u32) -> Result<()> {
    method set_down (line 126) | pub fn set_down(&mut self, index: u32) -> Result<()> {
    method set_ns_fd (line 159) | pub fn set_ns_fd(&mut self, index: u32, new_name: &str, ns_path: RawFd...
  function test_link_message_handler_success (line 191) | fn test_link_message_handler_success() {
  function test_link_message_handler_errorcode_zero (line 214) | fn test_link_message_handler_errorcode_zero() {
  function test_link_message_handler_error (line 230) | fn test_link_message_handler_error() {
  function test_link_message_handler_done (line 248) | fn test_link_message_handler_done() {
  function test_link_message_handler_unexpected (line 262) | fn test_link_message_handler_unexpected() {
  function test_link_client_new (line 274) | fn test_link_client_new() {
  function test_link_client_get_by_name_without_response (line 282) | fn test_link_client_get_by_name_without_response() {
  function test_link_client_get_by_name_with_response (line 293) | fn test_link_client_get_by_name_with_response() {
  function test_link_client_set_up_failure (line 318) | fn test_link_client_set_up_failure() {
  function test_link_client_set_up_success (line 331) | fn test_link_client_set_up_success() {
  function test_link_client_set_down_failure (line 372) | fn test_link_client_set_down_failure() {
  function test_link_client_set_down_success (line 385) | fn test_link_client_set_down_success() {
  function test_link_client_set_ns_fd_failure (line 423) | fn test_link_client_set_ns_fd_failure() {
  function test_link_client_set_ns_fd_success (line 436) | fn test_link_client_set_ns_fd_success() {

FILE: crates/libcontainer/src/network/mod.rs
  type NetworkError (line 11) | pub enum NetworkError {
  type Result (line 20) | type Result<T> = std::result::Result<T, NetworkError>;
  type NetlinkResponse (line 29) | pub enum NetlinkResponse<T> {

FILE: crates/libcontainer/src/network/network_device.rs
  function resolve_device_name (line 14) | pub fn resolve_device_name<'a>(device: &'a LinuxNetDevice, original_name...
  function dev_change_net_namespace (line 27) | pub fn dev_change_net_namespace(
  function setup_addresses_in_network_namespace (line 104) | pub fn setup_addresses_in_network_namespace(
  function test_setup_addresses_in_network_namespace (line 138) | fn test_setup_addresses_in_network_namespace() {
  function test_resolve_device_name_with_name (line 171) | fn test_resolve_device_name_with_name() {
  function test_resolve_device_name_with_empty_name (line 182) | fn test_resolve_device_name_with_empty_name() {
  function test_resolve_device_name_without_name (line 193) | fn test_resolve_device_name_without_name() {

FILE: crates/libcontainer/src/network/traits.rs
  type NetlinkMessageHandler (line 10) | pub trait NetlinkMessageHandler {
    method handle_payload (line 23) | fn handle_payload(
  type Client (line 32) | pub trait Client {
    method send (line 42) | fn send(&mut self, req: &NetlinkMessage<RouteNetlinkMessage>) -> Resul...
    method receive (line 53) | fn receive<T, H>(&mut self, handler: H) -> Result<T>
    method receive_multiple (line 66) | fn receive_multiple<T, H>(&mut self, handler: H) -> Result<Vec<T>>
    method send_and_receive (line 80) | fn send_and_receive<T, H>(
    method send_and_receive_multiple (line 98) | fn send_and_receive_multiple<T, H>(

FILE: crates/libcontainer/src/network/wrapper.rs
  type ClientWrapper (line 12) | pub enum ClientWrapper {
  method send (line 22) | fn send(&mut self, req: &NetlinkMessage<RouteNetlinkMessage>) -> Result<...
  method receive (line 30) | fn receive<T, H>(&mut self, handler: H) -> Result<T>
  method receive_multiple (line 41) | fn receive_multiple<T, H>(&mut self, handler: H) -> Result<Vec<T>>
  method send_and_receive (line 52) | fn send_and_receive<T, H>(
  method send_and_receive_multiple (line 67) | fn send_and_receive_multiple<T, H>(
  method default (line 84) | fn default() -> Self {
  function create_network_client (line 98) | pub fn create_network_client() -> ClientWrapper {

FILE: crates/libcontainer/src/notify_socket.rs
  constant NOTIFY_FILE (line 10) | pub const NOTIFY_FILE: &str = "notify.sock";
  type NotifyListenerError (line 13) | pub enum NotifyListenerError {
  type Result (line 40) | type Result<T> = std::result::Result<T, NotifyListenerError>;
  type NotifyListener (line 42) | pub struct NotifyListener {
    method new (line 47) | pub fn new(socket_path: &Path) -> Result<Self> {
    method wait_for_container_start (line 80) | pub fn wait_for_container_start(&self) -> Result<()> {
    method close (line 95) | pub fn close(&self) -> Result<()> {
  method clone (line 102) | fn clone(&self) -> Self {
  type NotifySocket (line 118) | pub struct NotifySocket {
    method new (line 123) | pub fn new<P: Into<PathBuf>>(socket_path: P) -> Self {
    method notify_container_start (line 129) | pub fn notify_container_start(&mut self) -> Result<()> {
  function test_notify_listener_clone (line 171) | fn test_notify_listener_clone() {

FILE: crates/libcontainer/src/process/args.rs
  type ContainerType (line 14) | pub enum ContainerType {
  type ContainerArgs (line 20) | pub struct ContainerArgs {

FILE: crates/libcontainer/src/process/channel.rs
  type ChannelError (line 11) | pub enum ChannelError {
  function main_channel (line 44) | pub fn main_channel() -> Result<(MainSender, MainReceiver), ChannelError> {
  type MainSender (line 49) | pub struct MainSender {
    method identifier_mapping_request (line 56) | pub fn identifier_mapping_request(&mut self) -> Result<(), ChannelErro...
    method seccomp_notify_request (line 63) | pub fn seccomp_notify_request(&mut self, fd: RawFd) -> Result<(), Chan...
    method network_setup_ready (line 70) | pub fn network_setup_ready(&mut self) -> Result<(), ChannelError> {
    method intermediate_ready (line 77) | pub fn intermediate_ready(&mut self, pid: Pid) -> Result<(), ChannelEr...
    method init_ready (line 85) | pub fn init_ready(&mut self) -> Result<(), ChannelError> {
    method exec_failed (line 91) | pub fn exec_failed(&mut self, err: String) -> Result<(), ChannelError> {
    method send_error (line 96) | pub fn send_error(&mut self, err: String) -> Result<(), ChannelError> {
    method hook_request (line 101) | pub fn hook_request(&mut self) -> Result<(), ChannelError> {
    method close (line 106) | pub fn close(&self) -> Result<(), ChannelError> {
  type MainReceiver (line 113) | pub struct MainReceiver {
    method wait_for_intermediate_ready (line 120) | pub fn wait_for_intermediate_ready(&mut self) -> Result<Pid, ChannelEr...
    method wait_for_mapping_request (line 140) | pub fn wait_for_mapping_request(&mut self) -> Result<(), ChannelError> {
    method wait_for_seccomp_request (line 157) | pub fn wait_for_seccomp_request(&mut self) -> Result<i32, ChannelError> {
    method wait_for_network_setup_ready (line 186) | pub fn wait_for_network_setup_ready(&mut self) -> Result<(), ChannelEr...
    method wait_for_init_ready (line 205) | pub fn wait_for_init_ready(&mut self) -> Result<(), ChannelError> {
    method wait_for_hook_request (line 226) | pub fn wait_for_hook_request(&mut self) -> Result<(), ChannelError> {
    method close (line 243) | pub fn close(&self) -> Result<(), ChannelError> {
  function intermediate_channel (line 250) | pub fn intermediate_channel() -> Result<(IntermediateSender, Intermediat...
  type IntermediateSender (line 258) | pub struct IntermediateSender {
    method mapping_written (line 263) | pub fn mapping_written(&mut self) -> Result<(), ChannelError> {
    method close (line 270) | pub fn close(&self) -> Result<(), ChannelError> {
  type IntermediateReceiver (line 277) | pub struct IntermediateReceiver {
    method wait_for_mapping_ack (line 283) | pub fn wait_for_mapping_ack(&mut self) -> Result<(), ChannelError> {
    method close (line 301) | pub fn close(&self) -> Result<(), ChannelError> {
  function init_channel (line 308) | pub fn init_channel() -> Result<(InitSender, InitReceiver), ChannelError> {
  type InitSender (line 313) | pub struct InitSender {
    method seccomp_notify_done (line 318) | pub fn seccomp_notify_done(&mut self) -> Result<(), ChannelError> {
    method hook_done (line 324) | pub fn hook_done(&mut self) -> Result<(), ChannelError> {
    method move_network_device (line 329) | pub fn move_network_device(
    method close (line 338) | pub fn close(&self) -> Result<(), ChannelError> {
  type InitReceiver (line 345) | pub struct InitReceiver {
    method wait_for_seccomp_request_done (line 350) | pub fn wait_for_seccomp_request_done(&mut self) -> Result<(), ChannelE...
    method wait_for_move_network_device (line 368) | pub fn wait_for_move_network_device(
    method wait_for_hook_request_done (line 387) | pub fn wait_for_hook_request_done(&mut self) -> Result<(), ChannelErro...
    method close (line 404) | pub fn close(&self) -> Result<(), ChannelError> {
  function test_channel_intermadiate_ready (line 429) | fn test_channel_intermadiate_ready() -> Result<()> {
  function test_channel_id_mapping_request (line 453) | fn test_channel_id_mapping_request() -> Result<()> {
  function test_channel_id_mapping_ack (line 475) | fn test_channel_id_mapping_ack() -> Result<()> {
  function test_channel_init_ready (line 495) | fn test_channel_init_ready() -> Result<()> {
  function test_channel_main_graceful_exit (line 517) | fn test_channel_main_graceful_exit() -> Result<()> {
  function test_channel_intermediate_graceful_exit (line 540) | fn test_channel_intermediate_graceful_exit() -> Result<()> {
  function test_move_network_device_message (line 563) | fn test_move_network_device_message() -> Result<()> {
  function test_network_setup_ready (line 611) | fn test_network_setup_ready() -> Result<()> {

FILE: crates/libcontainer/src/process/container_intermediate_process.rs
  type IntermediateProcessError (line 16) | pub enum IntermediateProcessError {
  type Result (line 39) | type Result<T> = std::result::Result<T, IntermediateProcessError>;
  function container_intermediate_process (line 41) | pub fn container_intermediate_process(
  function setup_userns (line 221) | fn setup_userns(
  function apply_cgroups (line 258) | fn apply_cgroups<
  function apply_cgroup_init (line 302) | fn apply_cgroup_init() -> Result<()> {
  function apply_cgroup_tenant (line 321) | fn apply_cgroup_tenant() -> Result<()> {
  function apply_cgroup_no_resources (line 339) | fn apply_cgroup_no_resources() -> Result<()> {

FILE: crates/libcontainer/src/process/container_main_process.rs
  type ProcessError (line 23) | pub enum ProcessError {
  type Result (line 51) | type Result<T> = std::result::Result<T, ProcessError>;
  function container_main_process (line 53) | pub fn container_main_process(container_args: &ContainerArgs) -> Result<...
  function setup_mapping (line 284) | fn setup_mapping(config: &UserNamespaceConfig, pid: Pid) -> Result<()> {
  function move_network_devices_to_container (line 308) | fn move_network_devices_to_container(
  function setup_uid_mapping_should_succeed (line 386) | fn setup_uid_mapping_should_succeed() -> Result<()> {
  function setup_gid_mapping_should_succeed (line 441) | fn setup_gid_mapping_should_succeed() -> Result<()> {

FILE: crates/libcontainer/src/process/cpu_affinity.rs
  type CPUAffinityError (line 6) | pub enum CPUAffinityError {
  type Result (line 23) | type Result<T> = std::result::Result<T, CPUAffinityError>;
  function to_cpuset (line 25) | pub fn to_cpuset(cpuset_str: &str) -> Result<CpuSet> {
  function parse_cpu_index (line 62) | fn parse_cpu_index(s: &str, max_cpu: usize) -> Result<usize> {
  function set_cpuset_affinity_from_string (line 75) | pub fn set_cpuset_affinity_from_string(pid: Pid, cpuset_str: &str) -> Re...
  function log_cpu_affinity (line 83) | pub fn log_cpu_affinity() -> Result<()> {
  function test_to_cpuset_single_values (line 100) | fn test_to_cpuset_single_values() {
  function test_to_cpuset_range (line 108) | fn test_to_cpuset_range() {
  function test_to_cpuset_mixed (line 116) | fn test_to_cpuset_mixed() {
  function test_to_cpuset_spaces_and_empty (line 127) | fn test_to_cpuset_spaces_and_empty() {
  function test_to_cpuset_invalid_range (line 135) | fn test_to_cpuset_invalid_range() {
  function test_to_cpuset_invalid_value (line 141) | fn test_to_cpuset_invalid_value() {
  function test_to_cpuset_max_allowed_cpu (line 147) | fn test_to_cpuset_max_allowed_cpu() {
  function test_to_cpuset_exceeds_max_cpu (line 155) | fn test_to_cpuset_exceeds_max_cpu() {

FILE: crates/libcontainer/src/process/fork.rs
  type CloneError (line 9) | pub enum CloneError {
  type CloneCb (line 35) | pub type CloneCb<'a> = Box<dyn FnMut() -> i32 + 'a>;
  function container_clone_sibling (line 44) | pub fn container_clone_sibling(cb: CloneCb) -> Result<Pid, CloneError> {
  function container_clone (line 54) | pub fn container_clone(cb: CloneCb) -> Result<Pid, CloneError> {
  function clone_internal (line 59) | fn clone_internal(
  function clone3 (line 80) | fn clone3(cb: &mut CloneCb, flags: u64, exit_signal: Option<u64>) -> Res...
  function clone (line 128) | fn clone(cb: CloneCb, flags: u64, exit_signal: Option<u64>) -> Result<Pi...
  function test_container_fork (line 249) | fn test_container_fork() -> Result<()> {
  function test_container_err_fork (line 262) | fn test_container_err_fork() -> Result<()> {
  function test_container_clone_sibling (line 275) | fn test_container_clone_sibling() -> Result<()> {
  function test_clone_fallback (line 329) | fn test_clone_fallback() -> Result<()> {

FILE: crates/libcontainer/src/process/init/context.rs
  type InitContext (line 14) | pub(crate) struct InitContext<'a> {
  function try_from (line 29) | pub fn try_from(args: &'a ContainerArgs) -> Result<Self> {

FILE: crates/libcontainer/src/process/init/error.rs
  type InitProcessError (line 12) | pub enum InitProcessError {

FILE: crates/libcontainer/src/process/init/mod.rs
  type Result (line 7) | type Result<T> = std::result::Result<T, error::InitProcessError>;

FILE: crates/libcontainer/src/process/init/process.rs
  function container_init_process (line 41) | pub fn container_init_process(
  function sysctl (line 474) | fn sysctl(kernel_params: &HashMap<String, String>) -> Result<()> {
  function readonly_path (line 503) | fn readonly_path(path: &Path, syscall: &dyn Syscall) -> Result<()> {
  function masked_paths (line 546) | fn masked_paths(
  function apply_rest_namespaces (line 603) | fn apply_rest_namespaces(
  function reopen_dev_null (line 641) | fn reopen_dev_null() -> Result<()> {
  function unmount_or_hide (line 681) | fn unmount_or_hide(syscall: &dyn Syscall, target: impl AsRef<Path>) -> R...
  function move_root (line 698) | fn move_root(syscall: &dyn Syscall, rootfs: &Path) -> Result<()> {
  function do_pivot_root (line 724) | fn do_pivot_root(
  function set_supplementary_gids (line 772) | fn set_supplementary_gids(
  function set_io_priority (line 825) | fn set_io_priority(syscall: &dyn Syscall, io_priority_op: &Option<LinuxI...
  function setup_scheduler (line 863) | fn setup_scheduler(sc_op: &Option<Scheduler>) -> Result<()> {
  function sync_seccomp (line 918) | fn sync_seccomp(
  function configure_container_network_devices (line 944) | fn configure_container_network_devices(
  function verify_cwd (line 1003) | fn verify_cwd() -> Result<()> {
  function set_home_env_if_not_exists (line 1023) | fn set_home_env_if_not_exists(envs: &mut HashMap<String, String>, uid: U...
  function set_home_from_path (line 1032) | fn set_home_from_path(envs: &mut HashMap<String, String>, dir_home: &Pat...
  function test_readonly_path (line 1058) | fn test_readonly_path() -> Result<()> {
  function test_apply_rest_namespaces (line 1095) | fn test_apply_rest_namespaces() -> Result<()> {
  function test_set_supplementary_gids (line 1130) | fn test_set_supplementary_gids() -> Result<()> {
  function test_sync_seccomp (line 1203) | fn test_sync_seccomp() -> Result<()> {
  function test_masked_path_does_not_exist (line 1227) | fn test_masked_path_does_not_exist() {
  function test_masked_path_mounts_via_fd (line 1243) | fn test_masked_path_mounts_via_fd() -> Result<()> {
  function test_masked_path_is_file_with_no_label (line 1261) | fn test_masked_path_is_file_with_no_label() {
  function test_masked_path_is_file_with_label (line 1287) | fn test_masked_path_is_file_with_label() {
  function test_masked_path_with_unknown_error (line 1315) | fn test_masked_path_with_unknown_error() {
  function test_set_io_priority (line 1340) | fn test_set_io_priority() {
  function test_set_home_env_if_not_exists_already_exists (line 1359) | fn test_set_home_env_if_not_exists_already_exists() {
  function test_set_home_env_if_not_exists_already_exists_non_root (line 1368) | fn test_set_home_env_if_not_exists_already_exists_non_root() {
  function test_set_home_env_if_not_exists_already_exists_but_empty_value (line 1377) | fn test_set_home_env_if_not_exists_already_exists_but_empty_value() {
  function test_set_home_env_if_not_exists_already_exists_but_empty_value_non_root (line 1386) | fn test_set_home_env_if_not_exists_already_exists_but_empty_value_non_ro...
  function test_set_home_env_if_not_exists_not_set (line 1407) | fn test_set_home_env_if_not_exists_not_set() {
  function test_set_home_env_if_not_exists_not_set_non_root (line 1415) | fn test_set_home_env_if_not_exists_not_set_non_root() {
  function test_set_home_from_path_valid_utf8 (line 1435) | fn test_set_home_from_path_valid_utf8() {
  function test_set_home_from_path_invalid_utf8 (line 1444) | fn test_set_home_from_path_invalid_utf8() {

FILE: crates/libcontainer/src/process/intel_rdt.rs
  type IntelRdtError (line 15) | pub enum IntelRdtError {
  type ParseLineError (line 57) | pub enum ParseLineError {
  type Result (line 68) | type Result<T> = std::result::Result<T, IntelRdtError>;
  function delete_resctrl_subdirectory (line 70) | pub fn delete_resctrl_subdirectory(id: &str) -> Result<()> {
  function find_resctrl_mount_point (line 98) | pub fn find_resctrl_mount_point() -> Result<PathBuf> {
  function write_container_pid_to_resctrl_tasks (line 124) | fn write_container_pid_to_resctrl_tasks(
  function combine_l3_cache_and_mem_bw_schemas (line 169) | fn combine_l3_cache_and_mem_bw_schemas(
  type LineType (line 197) | enum LineType {
  type ParsedLine (line 206) | struct ParsedLine {
  function parse_mb_line (line 212) | fn parse_mb_line(line: &str) -> std::result::Result<HashMap<String, Stri...
  function parse_l3_line (line 239) | fn parse_l3_line(line: &str) -> std::result::Result<HashMap<String, Stri...
  function get_line_type (line 269) | fn get_line_type(line: &str) -> LineType {
  function parse_line (line 288) | fn parse_line(line: &str) -> Option<std::result::Result<ParsedLine, Pars...
  function compare_lines (line 308) | fn compare_lines(first_lines: &[ParsedLine], second_lines: &[ParsedLine]...
  function is_same_schema (line 315) | fn is_same_schema(combined_schema: &str, existing_schema: &str) -> Resul...
  function write_resctrl_schemata (line 336) | fn write_resctrl_schemata(
  function setup_intel_rdt (line 377) | pub fn setup_intel_rdt(
  function test_combine_schemas (line 425) | fn test_combine_schemas() -> Result<()> {
  function test_is_same_schema (line 461) | fn test_is_same_schema() -> Result<()> {
  function test_write_pid_to_resctrl_tasks (line 533) | fn test_write_pid_to_resctrl_tasks() -> Result<()> {
  function test_write_resctrl_schemata (line 562) | fn test_write_resctrl_schemata() -> Result<()> {

FILE: crates/libcontainer/src/process/memory_policy.rs
  type MemoryPolicyError (line 8) | pub enum MemoryPolicyError {
  type Result (line 25) | type Result<T> = std::result::Result<T, MemoryPolicyError>;
  type MemoryPolicyMode (line 29) | enum MemoryPolicyMode {
    method from (line 46) | fn from(mode: MemoryPolicyModeType) -> Self {
    method fmt (line 60) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function from (line 40) | fn from(mode: MemoryPolicyMode) -> Self {
  type MemoryPolicyFlag (line 76) | enum MemoryPolicyFlag {
  function from (line 83) | fn from(flag: MemoryPolicyFlag) -> Self {
  type ValidatedMemoryPolicy (line 88) | struct ValidatedMemoryPolicy {
  function validate_memory_policy (line 94) | fn validate_memory_policy(
  function setup_memory_policy (line 250) | pub fn setup_memory_policy(
  function build_nodemask (line 267) | fn build_nodemask(nodes: &str) -> Result<(Vec<libc::c_ulong>, u64)> {
  function parse_node_string (line 302) | fn parse_node_string(nodes: &str) -> Result<Vec<u32>> {
  function test_parse_node_string (line 359) | fn test_parse_node_string() {
  function test_setup_memory_policy (line 395) | fn test_setup_memory_policy() {

FILE: crates/libcontainer/src/process/message.rs
  type Message (line 10) | pub enum Message {
    method fmt (line 26) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

FILE: crates/libcontainer/src/process/seccomp_listener.rs
  type SeccompListenerError (line 13) | pub enum SeccompListenerError {
  type Result (line 24) | type Result<T> = std::result::Result<T, SeccompListenerError>;
  function sync_seccomp (line 26) | pub fn sync_seccomp(
  function sync_seccomp_send_msg (line 54) | fn sync_seccomp_send_msg(listener_path: &Path, msg: &[u8], fd: i32) -> R...
  function test_sync_seccomp (line 121) | fn test_sync_seccomp() -> Result<()> {

FILE: crates/libcontainer/src/rootfs/device.rs
  type DeviceError (line 17) | pub enum DeviceError {
  type Result (line 30) | type Result<T> = std::result::Result<T, DeviceError>;
  function open_device_fd (line 32) | pub(crate) fn open_device_fd(dev_path: &Path) -> nix::Result<(OwnedFd, F...
  function verify_dev_null (line 43) | pub(crate) fn verify_dev_null(stat: &FileStat) -> Result<()> {
  type Device (line 61) | pub struct Device {
    method new (line 72) | pub fn new() -> Device {
    method new_with_syscall (line 78) | pub fn new_with_syscall(syscall: Box<dyn Syscall>) -> Device {
    method create_devices (line 82) | pub fn create_devices<'a, I>(&self, rootfs: &Path, devices: I, bind: b...
    method bind_dev (line 110) | fn bind_dev(&self, rootfs: &Path, dev: &LinuxDevice) -> Result<()> {
    method mknod_dev (line 146) | fn mknod_dev(&self, rootfs: &Path, dev: &LinuxDevice) -> Result<()> {
  method default (line 66) | fn default() -> Self {
  function create_container_dev_path (line 196) | fn create_container_dev_path(rootfs: &Path, dev: &LinuxDevice) -> Result...
  function test_bind_dev (line 239) | fn test_bind_dev() -> Result<()> {
  function test_mknod_dev (line 270) | fn test_mknod_dev() -> Result<()> {
  function test_create_devices (line 322) | fn test_create_devices() -> Result<()> {

FILE: crates/libcontainer/src/rootfs/mod.rs
  type RootfsError (line 19) | pub enum RootfsError {
  type Result (line 34) | type Result<T> = std::result::Result<T, RootfsError>;

FILE: crates/libcontainer/src/rootfs/mount.rs
  constant MAX_EBUSY_MOUNT_ATTEMPTS (line 35) | const MAX_EBUSY_MOUNT_ATTEMPTS: u32 = 3;
  constant MOUNT_RETRY_DELAY_MS (line 39) | const MOUNT_RETRY_DELAY_MS: u64 = 100;
  constant MOUNT_RETRY_DELAY_MS (line 42) | const MOUNT_RETRY_DELAY_MS: u64 = 0;
  type MountError (line 45) | pub enum MountError {
  type Result (line 70) | type Result<T> = std::result::Result<T, MountError>;
  type MountInfoProvider (line 72) | pub trait MountInfoProvider {
    method mountinfo (line 73) | fn mountinfo(&self) -> Result<Vec<MountInfo>>;
    method mountinfo (line 86) | fn mountinfo(&self) -> Result<Vec<MountInfo>> {
    method mountinfo (line 1237) | fn mountinfo(&self) -> std::result::Result<Vec<MountInfo>, MountError> {
  type ProcMountInfoProvider (line 77) | pub struct ProcMountInfoProvider;
    method new (line 80) | pub fn new() -> Self {
  type MountOptions (line 105) | pub struct MountOptions<'a> {
  type Mount (line 112) | pub struct Mount {
    method new (line 124) | pub fn new() -> Mount {
    method with_mountinfo_provider (line 131) | pub fn with_mountinfo_provider<P: MountInfoProvider + 'static>(mut sel...
    method setup_mount (line 136) | pub fn setup_mount(&self, mount: &SpecMount, options: &MountOptions) -...
    method mount_cgroup_v1 (line 244) | fn mount_cgroup_v1(&self, cgroup_mount: &SpecMount, options: &MountOpt...
    method setup_namespaced_subsystem (line 357) | fn setup_namespaced_subsystem(
    method setup_emulated_subsystem (line 409) | fn setup_emulated_subsystem(
    method mount_cgroup_v2 (line 472) | fn mount_cgroup_v2(
    method make_parent_mount_private (line 546) | pub fn make_parent_mount_private(&self, rootfs: &Path) -> Result<Mount...
    method mount_into_container (line 567) | fn mount_into_container(
    method mount_flag_to_attr (line 814) | fn mount_flag_to_attr(&self, flags: &MsFlags) -> u64 {
    method apply_atime_from_msflags (line 838) | fn apply_atime_from_msflags(
    method check_proc_mount (line 918) | pub fn check_proc_mount(&self, rootfs: &Path, mount: &SpecMount) -> Re...
  method default (line 118) | fn default() -> Self {
  function find_parent_mount (line 1006) | pub fn find_parent_mount(
  function test_mount_into_container (line 1036) | fn test_mount_into_container() -> Result<()> {
  type FakeMountInfo (line 1233) | struct FakeMountInfo {
  function test_make_parent_mount_private (line 1243) | fn test_make_parent_mount_private() -> Result<()> {
  function test_not_make_parent_mount_private_if_already_private (line 1286) | fn test_not_make_parent_mount_private_if_already_private() -> Result<()> {
  function test_namespaced_subsystem_success (line 1323) | fn test_namespaced_subsystem_success() -> Result<()> {
  function test_emulated_subsystem_success (line 1375) | fn test_emulated_subsystem_success() -> Result<()> {
  function test_mount_cgroup_v1 (line 1442) | fn test_mount_cgroup_v1() -> Result<()> {
  function test_mount_cgroup_v2 (line 1516) | fn test_mount_cgroup_v2() -> Result<()> {
  function test_find_parent_mount (line 1570) | fn test_find_parent_mount() -> anyhow::Result<()> {
  function test_find_parent_mount_with_empty_mount_infos (line 1605) | fn test_find_parent_mount_with_empty_mount_infos() {
  function test_check_proc_mount_proc_ok (line 1612) | fn test_check_proc_mount_proc_ok() -> Result<()> {
  function test_check_proc_mount_allowed_subpath (line 1627) | fn test_check_proc_mount_allowed_subpath() -> Result<()> {
  function test_check_proc_mount_denied_subpath (line 1644) | fn test_check_proc_mount_denied_subpath() -> Result<()> {
  function setup_mount_proc_fails_if_destination_is_symlink (line 1661) | fn setup_mount_proc_fails_if_destination_is_symlink() -> Result<()> {
  function setup_mount_sys_fails_if_destination_is_symlink (line 1696) | fn setup_mount_sys_fails_if_destination_is_symlink() -> Result<()> {

FILE: crates/libcontainer/src/rootfs/rootfs.rs
  type RootFS (line 17) | pub struct RootFS {
    method new (line 28) | pub fn new() -> RootFS {
    method mount_to_rootfs (line 34) | pub fn mount_to_rootfs(
    method prepare_rootfs (line 95) | pub fn prepare_rootfs(
    method adjust_root_mount_propagation (line 129) | pub fn adjust_root_mount_propagation(&self, linux: &Linux) -> Result<(...
  method default (line 22) | fn default() -> Self {

FILE: crates/libcontainer/src/rootfs/symlink.rs
  type SymlinkError (line 8) | pub enum SymlinkError {
  type Result (line 17) | type Result<T> = std::result::Result<T, SymlinkError>;
  type Symlink (line 19) | pub struct Symlink {
    method new (line 30) | pub fn new() -> Symlink {
    method with_syscall (line 34) | fn with_syscall(syscall: Box<dyn Syscall>) -> Symlink {
    method setup_comount_symlinks (line 40) | pub fn setup_comount_symlinks(&self, cgroup_root: &Path, subsystem_nam...
    method setup_ptmx (line 58) | pub fn setup_ptmx(&self, rootfs: &Path) -> Result<()> {
    method setup_kcore_symlink (line 79) | pub fn setup_kcore_symlink(&self, rootfs: &Path) -> Result<()> {
    method setup_default_symlinks (line 91) | pub fn setup_default_symlinks(&self, rootfs: &Path) -> Result<()> {
  method default (line 24) | fn default() -> Self {
  function test_setup_ptmx (line 128) | fn test_setup_ptmx() {
  function test_setup_default_symlinks (line 168) | fn test_setup_default_symlinks() {
  function setup_comounted_symlinks_success (line 201) | fn setup_comounted_symlinks_success() -> Result<()> {
  function setup_comounted_symlinks_no_comounts (line 244) | fn setup_comounted_symlinks_no_comounts() -> Result<()> {

FILE: crates/libcontainer/src/rootfs/utils.rs
  type MountOptionConfig (line 12) | pub struct MountOptionConfig {
  function default_devices (line 23) | pub fn default_devices() -> Vec<LinuxDevice> {
  function to_sflag (line 76) | pub fn to_sflag(dev_type: LinuxDeviceType) -> SFlag {
  function parse_mount (line 85) | pub fn parse_mount(m: &Mount) -> std::result::Result<MountOptionConfig, ...
  function test_to_sflag (line 204) | fn test_to_sflag() {
  function test_parse_mount (line 216) | fn test_parse_mount() -> Result<()> {

FILE: crates/libcontainer/src/seccomp/mod.rs
  type SeccompError (line 12) | pub enum SeccompError {
  type Result (line 52) | type Result<T> = std::result::Result<T, SeccompError>;
  function translate_arch (line 54) | fn translate_arch(arch: Arch) -> ScmpArch {
  function translate_action (line 77) | fn translate_action(action: LinuxSeccompAction, errno: Option<u32>) -> R...
  function translate_op (line 100) | fn translate_op(op: LinuxSeccompOperator, datum_b: Option<u64>) -> ScmpC...
  function check_seccomp (line 112) | fn check_seccomp(seccomp: &LinuxSeccomp) -> Result<()> {
  function initialize_seccomp (line 143) | pub fn initialize_seccomp(seccomp: &LinuxSeccomp) -> Result<Option<io::R...
  function is_notify (line 281) | pub fn is_notify(seccomp: &LinuxSeccomp) -> bool {
  function test_basic (line 302) | fn test_basic() -> Result<()> {
  function test_moby (line 353) | fn test_moby() -> Result<()> {
  function test_seccomp_notify (line 373) | fn test_seccomp_notify() -> Result<()> {

FILE: crates/libcontainer/src/signal.rs
  type Signal (line 9) | pub struct Signal(NixSignal);
    type Error (line 18) | type Error = SignalError<String>;
    method try_from (line 20) | fn try_from(s: &str) -> Result<Self, Self::Error> {
    type Error (line 61) | type Error = SignalError<i32>;
    method try_from (line 63) | fn try_from(value: i32) -> Result<Self, Self::Error> {
    method from (line 71) | fn from(s: NixSignal) -> Self {
    method into_raw (line 77) | pub(crate) fn into_raw(self) -> NixSignal {
  type SignalError (line 12) | pub enum SignalError<T> {
  function test_conversion_from_string (line 91) | fn test_conversion_from_string() {
  function test_conversion_from_string_should_be_failed (line 132) | fn test_conversion_from_string_should_be_failed() {

FILE: crates/libcontainer/src/syscall/linux.rs
  constant AT_RECURSIVE (line 32) | pub const AT_RECURSIVE: u32 = 0x00008000;
  constant AT_EMPTY_PATH (line 33) | pub const AT_EMPTY_PATH: u32 = 0x00001000;
  constant MOUNT_ATTR__ATIME (line 35) | pub const MOUNT_ATTR__ATIME: u64 = 0x00000070;
  constant MOUNT_ATTR_RDONLY (line 36) | pub const MOUNT_ATTR_RDONLY: u64 = 0x00000001;
  constant MOUNT_ATTR_NOSUID (line 37) | pub const MOUNT_ATTR_NOSUID: u64 = 0x00000002;
  constant MOUNT_ATTR_NODEV (line 38) | pub const MOUNT_ATTR_NODEV: u64 = 0x00000004;
  constant MOUNT_ATTR_NOEXEC (line 39) | pub const MOUNT_ATTR_NOEXEC: u64 = 0x00000008;
  constant MOUNT_ATTR_RELATIME (line 40) | pub const MOUNT_ATTR_RELATIME: u64 = 0x00000000;
  constant MOUNT_ATTR_NOATIME (line 41) | pub const MOUNT_ATTR_NOATIME: u64 = 0x00000010;
  constant MOUNT_ATTR_STRICTATIME (line 42) | pub const MOUNT_ATTR_STRICTATIME: u64 = 0x00000020;
  constant MOUNT_ATTR_NODIRATIME (line 43) | pub const MOUNT_ATTR_NODIRATIME: u64 = 0x00000080;
  constant MOUNT_ATTR_NOSYMFOLLOW (line 44) | pub const MOUNT_ATTR_NOSYMFOLLOW: u64 = 0x00200000;
  constant MOVE_MOUNT_F_EMPTY_PATH (line 45) | pub const MOVE_MOUNT_F_EMPTY_PATH: u32 = 0x00000004;
  constant MOVE_MOUNT_T_EMPTY_PATH (line 46) | pub const MOVE_MOUNT_T_EMPTY_PATH: u32 = 0x00000040;
  constant FSCONFIG_SET_FLAG (line 49) | pub const FSCONFIG_SET_FLAG: u64 = 0;
  constant FSCONFIG_SET_STRING (line 50) | pub const FSCONFIG_SET_STRING: u64 = 1;
  constant FSCONFIG_SET_BINARY (line 51) | pub const FSCONFIG_SET_BINARY: u64 = 2;
  constant FSCONFIG_SET_PATH (line 52) | pub const FSCONFIG_SET_PATH: u64 = 3;
  constant FSCONFIG_SET_PATH_EMPTY (line 53) | pub const FSCONFIG_SET_PATH_EMPTY: u64 = 4;
  constant FSCONFIG_SET_FD (line 54) | pub const FSCONFIG_SET_FD: u64 = 5;
  constant FSCONFIG_CMD_CREATE (line 55) | pub const FSCONFIG_CMD_CREATE: u64 = 6;
  constant FSCONFIG_CMD_RECONFIGURE (line 56) | pub const FSCONFIG_CMD_RECONFIGURE: u64 = 7;
  constant FSCONFIG_CMD_CREATE_EXCL (line 57) | pub const FSCONFIG_CMD_CREATE_EXCL: u64 = 8;
  type MountOption (line 60) | pub enum MountOption {
    method known_options (line 98) | pub fn known_options() -> Vec<String> {
  type Err (line 141) | type Err = String;
  method from_str (line 143) | fn from_str(option: &str) -> std::result::Result<Self, Self::Err> {
  type MountRecursive (line 199) | pub enum MountRecursive {
  type Err (line 232) | type Err = SyscallError;
  method from_str (line 234) | fn from_str(option: &str) -> std::result::Result<Self, Self::Err> {
  type MountAttr (line 265) | pub struct MountAttr {
    method all (line 282) | pub fn all() -> Self {
  type LinuxSyscall (line 311) | pub struct LinuxSyscall;
    method from_raw_buf (line 314) | unsafe fn from_raw_buf<'a, T>(p: *const c_char) -> T
    method passwd_to_user (line 322) | unsafe fn passwd_to_user(passwd: libc::passwd) -> Arc<OsStr> {
    method emulate_close_range (line 327) | fn emulate_close_range(preserve_fds: i32) -> Result<()> {
    method get_open_fds (line 346) | fn get_open_fds() -> Result<Vec<i32>> {
  method as_any (line 375) | fn as_any(&self) -> &dyn Any {
  method pivot_rootfs (line 380) | fn pivot_rootfs(&self, path: &Path) -> Result<()> {
  method set_ns (line 436) | fn set_ns(&self, rawfd: i32, nstype: CloneFlags) -> Result<()> {
  method set_id (line 443) | fn set_id(&self, uid: Uid, gid: Gid) -> Result<()> {
  method unshare (line 489) | fn unshare(&self, flags: CloneFlags) -> Result<()> {
  method set_capability (line 495) | fn set_capability(&self, cset: CapSet, value: &CapsHashSet) -> Result<()> {
  method set_hostname (line 533) | fn set_hostname(&self, hostname: &str) -> Result<()> {
  method set_domainname (line 540) | fn set_domainname(&self, domainname: &str) -> Result<()> {
  method set_rlimit (line 554) | fn set_rlimit(&self, rlimit: &PosixRlimit) -> Result<()> {
  method get_pwuid (line 576) | fn get_pwuid(&self, uid: uid_t) -> Option<Arc<OsStr>> {
  method chroot (line 609) | fn chroot(&self, path: &Path) -> Result<()> {
  method mount (line 615) | fn mount(
  method mount_from_fd (line 627) | fn mount_from_fd(&self, source_fd: &OwnedFd, target: &Path) -> Result<()> {
  method move_mount (line 692) | fn move_mount(
  method fsopen (line 734) | fn fsopen(&self, fstype: Option<&str>, flags: u32) -> Result<OwnedFd> {
  method fsconfig (line 749) | fn fsconfig(
  method fsmount (line 785) | fn fsmount(
  method open_tree (line 809) | fn open_tree(&self, dirfd: RawFd, path: Option<&str>, flags: u32) -> Res...
  method symlink (line 834) | fn symlink(&self, original: &Path, link: &Path) -> Result<()> {
  method mknod (line 840) | fn mknod(&self, path: &Path, kind: SFlag, perm: Mode, dev: u64) -> Resul...
  method chown (line 846) | fn chown(&self, path: &Path, owner: Option<Uid>, group: Option<Gid>) -> ...
  method set_groups (line 852) | fn set_groups(&self, groups: &[Gid]) -> Result<()> {
  method close_range (line 867) | fn close_range(&self, preserve_fds: i32) -> Result<()> {
  method mount_setattr (line 893) | fn mount_setattr(
  method set_io_priority (line 931) | fn set_io_priority(&self, class: i64, priority: i64) -> Result<()> {
  method set_mempolicy (line 950) | fn set_mempolicy(&self, mode: i32, nodemask: &[libc::c_ulong], maxnode: ...
  method umount2 (line 973) | fn umount2(&self, target: &Path, flags: MntFlags) -> Result<()> {
  method get_uid (line 978) | fn get_uid(&self) -> Uid {
  method get_gid (line 982) | fn get_gid(&self) -> Gid {
  method get_euid (line 986) | fn get_euid(&self) -> Uid {
  method get_egid (line 990) | fn get_egid(&self) -> Gid {
  method personality (line 994) | fn personality(&self, domain: PersonalityDomain) -> Result<()> {
  function test_get_open_fds (line 1022) | fn test_get_open_fds() -> Result<()> {
  function test_close_range_userspace (line 1047) | fn test_close_range_userspace() -> Result<()> {
  function test_close_range_native (line 1064) | fn test_close_range_native() -> Result<()> {
  function test_known_mount_options_implemented (line 1081) | fn test_known_mount_options_implemented() -> Result<()> {

FILE: crates/libcontainer/src/syscall/mod.rs
  type SyscallError (line 12) | pub enum SyscallError {
  type Result (line 25) | type Result<T> = std::result::Result<T, SyscallError>;

FILE: crates/libcontainer/src/syscall/syscall.rs
  type Syscall (line 26) | pub trait Syscall {
    method as_any (line 27) | fn as_any(&self) -> &dyn Any;
    method pivot_rootfs (line 28) | fn pivot_rootfs(&self, path: &Path) -> Result<()>;
    method chroot (line 29) | fn chroot(&self, path: &Path) -> Result<()>;
    method set_ns (line 30) | fn set_ns(&self, rawfd: i32, nstype: CloneFlags) -> Result<()>;
    method set_id (line 31) | fn set_id(&self, uid: Uid, gid: Gid) -> Result<()>;
    method unshare (line 32) | fn unshare(&self, flags: CloneFlags) -> Result<()>;
    method set_capability (line 33) | fn set_capability(&self, cset: CapSet, value: &CapsHashSet) -> Result<...
    method set_hostname (line 34) | fn set_hostname(&self, hostname: &str) -> Result<()>;
    method set_domainname (line 35) | fn set_domainname(&self, domainname: &str) -> Result<()>;
    method set_rlimit (line 36) | fn set_rlimit(&self, rlimit: &PosixRlimit) -> Result<()>;
    method get_pwuid (line 37) | fn get_pwuid(&self, uid: u32) -> Option<Arc<OsStr>>;
    method mount (line 38) | fn mount(
    method mount_from_fd (line 48) | fn mount_from_fd(&self, source_fd: &OwnedFd, target: &Path) -> Result<...
    method move_mount (line 49) | fn move_mount(
    method fsopen (line 57) | fn fsopen(&self, fstype: Option<&str>, flags: u32) -> Result<OwnedFd>;
    method fsconfig (line 58) | fn fsconfig(
    method fsmount (line 66) | fn fsmount(&self, fsfd: BorrowedFd<'_>, flags: u32, attr_flags: Option...
    method open_tree (line 68) | fn open_tree(&self, dirfd: RawFd, path: Option<&str>, flags: u32) -> R...
    method symlink (line 69) | fn symlink(&self, original: &Path, link: &Path) -> Result<()>;
    method mknod (line 70) | fn mknod(&self, path: &Path, kind: SFlag, perm: Mode, dev: u64) -> Res...
    method chown (line 71) | fn chown(&self, path: &Path, owner: Option<Uid>, group: Option<Gid>) -...
    method set_groups (line 72) | fn set_groups(&self, groups: &[Gid]) -> Result<()>;
    method close_range (line 73) | fn close_range(&self, preserve_fds: i32) -> Result<()>;
    method mount_setattr (line 74) | fn mount_setattr(
    method set_io_priority (line 82) | fn set_io_priority(&self, class: i64, priority: i64) -> Result<()>;
    method set_mempolicy (line 83) | fn set_mempolicy(&self, mode: i32, nodemask: &[libc::c_ulong], maxnode...
    method umount2 (line 84) | fn umount2(&self, target: &Path, flags: MntFlags) -> Result<()>;
    method get_uid (line 85) | fn get_uid(&self) -> Uid;
    method get_gid (line 86) | fn get_gid(&self) -> Gid;
    method get_euid (line 87) | fn get_euid(&self) -> Uid;
    method get_egid (line 88) | fn get_egid(&self) -> Gid;
    method personality (line 89) | fn personality(&self, domain: PersonalityDomain) -> Result<()>;
  type SyscallType (line 93) | pub enum SyscallType {
    method create_syscall (line 109) | pub fn create_syscall(&self) -> Box<dyn Syscall> {
  method default (line 99) | fn default() -> Self {
  function create_syscall (line 117) | pub fn create_syscall() -> Box<dyn Syscall> {

FILE: crates/libcontainer/src/syscall/test.rs
  type MountArgs (line 21) | pub struct MountArgs {
  type MountFromFdArgs (line 30) | pub struct MountFromFdArgs {
  type MoveMountArgs (line 36) | pub struct MoveMountArgs {
  type FsopenArgs (line 45) | pub struct FsopenArgs {
  type MknodArgs (line 51) | pub struct MknodArgs {
  type ChownArgs (line 59) | pub struct ChownArgs {
  type IoPriorityArgs (line 66) | pub struct IoPriorityArgs {
  type MemPolicyArgs (line 72) | pub struct MemPolicyArgs {
  type UMount2Args (line 79) | pub struct UMount2Args {
  type Mock (line 85) | struct Mock {
  type ArgName (line 92) | pub enum ArgName {
    method iterator (line 112) | fn iterator() -> impl Iterator<Item = ArgName> {
  type MockCalls (line 134) | struct MockCalls {
    method act (line 153) | fn act(&self, name: ArgName, value: Box<dyn Any>) -> Result<()> {
    method fetch (line 170) | fn fetch(&self, name: ArgName) -> Ref<'_, Mock> {
    method fetch_mut (line 174) | fn fetch_mut(&self, name: ArgName) -> RefMut<'_, Mock> {
  method default (line 139) | fn default() -> Self {
  type TestHelperSyscall (line 180) | pub struct TestHelperSyscall {
    method set_ret_err (line 432) | pub fn set_ret_err(&self, name: ArgName, err: fn() -> Result<()>) {
    method set_ret_err_times (line 437) | pub fn set_ret_err_times(&self, name: ArgName, times: usize) {
    method get_setns_args (line 441) | pub fn get_setns_args(&self) -> Vec<(i32, CloneFlags)> {
    method get_unshare_args (line 450) | pub fn get_unshare_args(&self) -> Vec<CloneFlags> {
    method get_set_capability_args (line 459) | pub fn get_set_capability_args(&self) -> Vec<(CapSet, CapsHashSet)> {
    method get_mount_args (line 468) | pub fn get_mount_args(&self) -> Vec<MountArgs> {
    method get_mount_from_fd_args (line 477) | pub fn get_mount_from_fd_args(&self) -> Vec<MountFromFdArgs> {
    method get_symlink_args (line 486) | pub fn get_symlink_args(&self) -> Vec<(PathBuf, PathBuf)> {
    method get_mknod_args (line 495) | pub fn get_mknod_args(&self) -> Vec<MknodArgs> {
    method get_chown_args (line 504) | pub fn get_chown_args(&self) -> Vec<ChownArgs> {
    method get_hostname_args (line 513) | pub fn get_hostname_args(&self) -> Vec<String> {
    method get_domainname_args (line 522) | pub fn get_domainname_args(&self) -> Vec<String> {
    method get_groups_args (line 531) | pub fn get_groups_args(&self) -> Vec<Gid> {
    method get_io_priority_args (line 540) | pub fn get_io_priority_args(&self) -> Vec<IoPriorityArgs> {
    method get_mempolicy_args (line 549) | pub fn get_mempolicy_args(&self) -> Vec<MemPolicyArgs> {
    method get_umount_args (line 558) | pub fn get_umount_args(&self) -> Vec<UMount2Args> {
  type MockId (line 185) | pub struct MockId {
  method default (line 193) | fn default() -> Self {
  method as_any (line 204) | fn as_any(&self) -> &dyn Any {
  method pivot_rootfs (line 208) | fn pivot_rootfs(&self, _path: &Path) -> Result<()> {
  method set_ns (line 212) | fn set_ns(&self, rawfd: i32, nstype: CloneFlags) -> Result<()> {
  method set_id (line 217) | fn set_id(&self, _uid: Uid, _gid: Gid) -> Result<()> {
  method unshare (line 225) | fn unshare(&self, flags: CloneFlags) -> Result<()> {
  method set_capability (line 229) | fn set_capability(&self, cset: CapSet, value: &CapsHashSet) -> Result<()> {
  method set_hostname (line 234) | fn set_hostname(&self, hostname: &str) -> Result<()> {
  method set_domainname (line 239) | fn set_domainname(&self, domainname: &str) -> Result<()> {
  method set_rlimit (line 244) | fn set_rlimit(&self, _rlimit: &PosixRlimit) -> Result<()> {
  method get_pwuid (line 248) | fn get_pwuid(&self, _: u32) -> Option<Arc<OsStr>> {
  method chroot (line 252) | fn chroot(&self, _: &Path) -> Result<()> {
  method mount (line 256) | fn mount(
  method mount_from_fd (line 283) | fn mount_from_fd(&self, source_fd: &OwnedFd, target: &Path) -> Result<()> {
  method move_mount (line 293) | fn move_mount(
  method fsopen (line 311) | fn fsopen(&self, _: Option<&str>, _: u32) -> Result<OwnedFd> {
  method fsconfig (line 315) | fn fsconfig(
  method fsmount (line 326) | fn fsmount(&self, _: BorrowedFd<'_>, _: u32, _: Option<u64>) -> Result<O...
  method open_tree (line 330) | fn open_tree(&self, _: RawFd, _: Option<&str>, _: u32) -> Result<OwnedFd> {
  method symlink (line 334) | fn symlink(&self, original: &Path, link: &Path) -> Result<()> {
  method mknod (line 341) | fn mknod(&self, path: &Path, kind: SFlag, perm: Mode, dev: u64) -> Resul...
  method chown (line 352) | fn chown(&self, path: &Path, owner: Option<Uid>, group: Option<Gid>) -> ...
  method set_groups (line 363) | fn set_groups(&self, groups: &[Gid]) -> Result<()> {
  method close_range (line 367) | fn close_range(&self, _: i32) -> Result<()> {
  method mount_setattr (line 371) | fn mount_setattr(
  method set_io_priority (line 382) | fn set_io_priority(&self, class: i64, priority: i64) -> Result<()> {
  method set_mempolicy (line 389) | fn set_mempolicy(&self, mode: i32, nodemask: &[libc::c_ulong], maxnode: ...
  method umount2 (line 400) | fn umount2(&self, target: &Path, flags: MntFlags) -> Result<()> {
  method get_uid (line 410) | fn get_uid(&self) -> Uid {
  method get_gid (line 414) | fn get_gid(&self) -> Gid {
  method get_euid (line 418) | fn get_euid(&self) -> Uid {
  method get_egid (line 422) | fn get_egid(&self) -> Gid {
  method personality (line 426) | fn personality(&self, _: PersonalityDomain) -> Result<()> {

FILE: crates/libcontainer/src/test_utils.rs
  type ErrorEnclosure (line 8) | struct ErrorEnclosure {
    method new (line 14) | pub fn new<T>(e: &T) -> ErrorEnclosure
    method fmt (line 26) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method source (line 32) | fn source(&self) -> Option<&(dyn 'static + std::error::Error)> {
    method description (line 38) | fn description(&self) -> &str {
  type ClosureResult (line 43) | type ClosureResult = Result<(), ErrorEnclosure>;
  type TestError (line 46) | pub enum TestError {
  type TestCallbackError (line 60) | pub enum TestCallbackError {
    method from (line 68) | fn from(s: &str) -> Self {
    method from (line 74) | fn from(s: String) -> Self {
  function test_in_child_process (line 79) | pub fn test_in_child_process<F>(cb: F) -> Result<(), TestError>
  function test_child_process (line 119) | fn test_child_process() -> Result<()> {
  function test_panic_child_process (line 130) | fn test_panic_child_process() -> Result<()> {

FILE: crates/libcontainer/src/tty.rs
  type StdIO (line 32) | pub enum StdIO {
    method fmt (line 49) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function from (line 39) | fn from(value: StdIO) -> Self {
  type TTYError (line 59) | pub enum TTYError {
  type Result (line 98) | type Result<T> = std::result::Result<T, TTYError>;
  function setup_console_socket (line 101) | pub fn setup_console_socket(
  constant PTMX_MAJOR (line 152) | const PTMX_MAJOR: u64 = 5;
  constant PTMX_MINOR (line 154) | const PTMX_MINOR: u64 = 2;
  constant PTMX_INO (line 156) | const PTMX_INO: u64 = 2;
  constant PTY_SLAVE_MAJOR (line 158) | const PTY_SLAVE_MAJOR: u64 = 136;
  constant DEVPTS_SUPER_MAGIC (line 164) | const DEVPTS_SUPER_MAGIC: u64 = 0x1cd1;
  constant DEVPTS_SUPER_MAGIC (line 166) | const DEVPTS_SUPER_MAGIC: i64 = 0x1cd1;
  constant PTMX_PATH (line 168) | const PTMX_PATH: &[u8] = b"/dev/ptmx";
  constant CONSOLE_PATH (line 170) | const CONSOLE_PATH: &str = "/dev/console";
  function verify_ptmx_handle (line 180) | fn verify_ptmx_handle(ptmx: &OwnedFd) -> Result<()> {
  function verify_pty_slave (line 231) | fn verify_pty_slave(slave: &OwnedFd) -> Result<()> {
  function setup_console (line 286) | pub fn setup_console(syscall: &dyn Syscall, console_fd: RawFd, mount: bo...
  function mount_console (line 335) | fn mount_console(syscall: &dyn Syscall, slave: &OwnedFd) -> Result<()> {
  function connect_stdio (line 378) | fn connect_stdio(stdin: &RawFd, stdout: &RawFd, stderr: &RawFd) -> Resul...
  constant CONSOLE_SOCKET (line 408) | const CONSOLE_SOCKET: &str = "console-socket";
  function test_setup_console_socket (line 412) | fn test_setup_console_socket() -> Result<()> {
  function test_setup_console_socket_empty (line 424) | fn test_setup_console_socket_empty() -> Result<()> {
  function test_setup_console_socket_invalid (line 434) | fn test_setup_console_socket_invalid() -> Result<()> {
  function test_setup_console (line 447) | fn test_setup_console() -> Result<()> {
  function test_verify_pty_slave_with_real_pty (line 480) | fn test_verify_pty_slave_with_real_pty() -> Result<()> {
  function test_verify_ptmx_handle_with_real_pty (line 493) | fn test_verify_ptmx_handle_with_real_pty() -> Result<()> {
  function test_verify_ptmx_handle_with_regular_file (line 506) | fn test_verify_ptmx_handle_with_regular_file() {
  function test_verify_pty_slave_with_regular_file (line 533) | fn test_verify_pty_slave_with_regular_file() {

FILE: crates/libcontainer/src/user_ns.rs
  type UserNamespaceIDMapper (line 16) | pub struct UserNamespaceIDMapper {
    method new (line 34) | pub fn new() -> Self {
    method get_uid_path (line 38) | pub fn get_uid_path(&self, pid: &Pid) -> PathBuf {
    method get_gid_path (line 41) | pub fn get_gid_path(&self, pid: &Pid) -> PathBuf {
    method ensure_uid_path (line 46) | pub fn ensure_uid_path(&self, pid: &Pid) -> std::result::Result<(), st...
    method ensure_gid_path (line 53) | pub fn ensure_gid_path(&self, pid: &Pid) -> std::result::Result<(), st...
    method new_test (line 61) | pub fn new_test(path: PathBuf) -> Self {
  method default (line 21) | fn default() -> Self {
  type UserNamespaceError (line 67) | pub enum UserNamespaceError {
  type Result (line 86) | type Result<T> = std::result::Result<T, UserNamespaceError>;
  type ValidateSpecError (line 89) | pub enum ValidateSpecError {
  type MappingError (line 115) | pub enum MappingError {
  type UserNamespaceConfig (line 129) | pub struct UserNamespaceConfig {
    method new (line 147) | pub fn new(spec: &Spec) -> Result<Option<Self>> {
    method write_uid_mapping (line 176) | pub fn write_uid_mapping(&self, target_pid: Pid) -> Result<()> {
    method write_gid_mapping (line 189) | pub fn write_gid_mapping(&self, target_pid: Pid) -> Result<()> {
    method with_id_mapper (line 202) | pub fn with_id_mapper(&mut self, mapper: UserNamespaceIDMapper) {
    type Error (line 208) | type Error = UserNamespaceError;
    method try_from (line 210) | fn try_from(linux: &Linux) -> Result<Self> {
  function unprivileged_user_ns_enabled (line 229) | pub fn unprivileged_user_ns_enabled() -> Result<bool> {
  function validate_spec_for_new_user_ns (line 251) | fn validate_spec_for_new_user_ns(
  function validate_mounts_for_new_user_ns (line 319) | fn validate_mounts_for_new_user_ns(
  function is_id_mapped (line 365) | fn is_id_mapped(id: u32, mappings: &[LinuxIdMapping]) -> bool {
  function lookup_map_binaries (line 373) | pub fn lookup_map_binaries(
  function lookup_map_binary (line 393) | fn lookup_map_binary(binary: &str) -> std::result::Result<Option<PathBuf...
  function write_id_mapping (line 401) | fn write_id_mapping(
  function gen_u32 (line 464) | fn gen_u32() -> u32 {
  function test_validate_ok (line 469) | fn test_validate_ok() -> Result<()> {
  function test_validate_err (line 499) | fn test_validate_err() -> Result<()> {
  function test_write_uid_mapping (line 586) | fn test_write_uid_mapping() -> Result<()> {
  function test_write_gid_mapping (line 635) | fn test_write_gid_mapping() -> Result<()> {

FILE: crates/libcontainer/src/utils.rs
  type PathBufExtError (line 22) | pub enum PathBufExtError {
  type PathBufExt (line 39) | pub trait PathBufExt {
    method as_relative (line 40) | fn as_relative(&self) -> Result<&Path, PathBufExtError>;
    method join_safely (line 41) | fn join_safely<P: AsRef<Path>>(&self, p: P) -> Result<PathBuf, PathBuf...
    method canonicalize_safely (line 42) | fn canonicalize_safely(&self) -> Result<PathBuf, PathBufExtError>;
    method normalize (line 43) | fn normalize(&self) -> PathBuf;
    method as_relative (line 47) | fn as_relative(&self) -> Result<&Path, PathBufExtError> {
    method join_safely (line 59) | fn join_safely<P: AsRef<Path>>(&self, path: P) -> Result<PathBuf, Path...
    method canonicalize_safely (line 75) | fn canonicalize_safely(&self) -> Result<PathBuf, PathBufExtError> {
    method normalize (line 96) | fn normalize(&self) -> PathBuf {
  function parse_env (line 124) | pub fn parse_env(envs: &[String]) -> HashMap<String, String> {
  function get_unix_user (line 138) | pub fn get_unix_user(uid: Uid) -> Option<User> {
  function get_user_home (line 143) | pub fn get_user_home(uid: u32) -> Option<PathBuf> {
  function get_cgroup_path (line 151) | pub fn get_cgroup_path(cgroups_path: &Option<PathBuf>, container_id: &st...
  function write_file (line 158) | pub fn write_file<P: AsRef<Path>, C: AsRef<[u8]>>(
  function create_dir_all (line 170) | pub fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<(), std::io::Er...
  function open (line 178) | pub fn open<P: AsRef<Path>>(path: P) -> Result<File, std::io::Error> {
  type MkdirWithModeError (line 186) | pub enum MkdirWithModeError {
  type VerifyInodeError (line 194) | pub enum VerifyInodeError {
  function verify_inode (line 215) | pub fn verify_inode<F>(fd: &OwnedFd, verify: F) -> Result<(), VerifyInod...
  function create_dir_all_with_mode (line 237) | pub fn create_dir_all_with_mode<P: AsRef<Path>>(
  function is_in_new_userns (line 261) | pub fn is_in_new_userns() -> Result<bool, std::io::Error> {
  function rootless_required (line 268) | pub fn rootless_required(syscall: &dyn Syscall) -> Result<bool, std::io:...
  function validate_spec_for_new_user_ns (line 276) | pub fn validate_spec_for_new_user_ns(
  function retry (line 299) | pub fn retry<F, T, E, P>(mut op: F, attempts: u32, delay: Duration, poli...
  type NetDevicesError (line 323) | pub enum NetDevicesError {
  function validate_spec_for_net_devices (line 337) | pub fn validate_spec_for_net_devices(
  function validate_mount_options (line 386) | pub fn validate_mount_options(
  function dev_valid_name (line 405) | fn dev_valid_name(name: &str) -> bool {
  function test_get_unix_user (line 436) | pub fn test_get_unix_user() {
  function test_get_user_home (line 446) | pub fn test_get_user_home() {
  function test_get_cgroup_path (line 456) | fn test_get_cgroup_path() {
  function test_parse_env (line 469) | fn test_parse_env() -> Result<()> {
  function test_create_dir_all_with_mode (line 485) | fn test_create_dir_all_with_mode() -> Result<()> {
  function test_io (line 513) | fn test_io() -> Result<()> {
  function test_userns_spec_validation (line 542) | fn test_userns_spec_validation() -> Result<(), test_utils::TestError> {
  function test_dev_valid_name (line 573) | fn test_dev_valid_name() {
  function build_spec_with_ns_and_devices (line 593) | fn build_spec_with_ns_and_devices(include_net_ns: bool, devices: Vec<(&s...
  function test_net_devices_none (line 624) | fn test_net_devices_none() {
  function test_missing_net_namespace (line 633) | fn test_missing_net_namespace() {
  function test_invalid_device_name (line 641) | fn test_invalid_device_name() {
  function test_valid_config (line 654) | fn test_valid_config() {

FILE: crates/libcontainer/src/workload/default.rs
  type DefaultExecutor (line 10) | pub struct DefaultExecutor {}
  method exec (line 13) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
  method validate (line 49) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError> {
  function get_executor (line 111) | pub fn get_executor() -> Box<dyn Executor> {
  function get_executable_path (line 115) | fn get_executable_path(name: &str, path_var: &str) -> Option<PathBuf> {
  function is_executable (line 129) | fn is_executable(path: &Path) -> std::result::Result<bool, std::io::Erro...
  function test_get_executable_path (line 149) | fn test_get_executable_path() {
  function test_is_executable (line 171) | fn test_is_executable() {
  function test_executor_set_envs (line 188) | fn test_executor_set_envs() {

FILE: crates/libcontainer/src/workload/mod.rs
  type ExecutorError (line 11) | pub enum ExecutorError {
  type ExecutorValidationError (line 23) | pub enum ExecutorValidationError {
  type ExecutorSetEnvsError (line 31) | pub enum ExecutorSetEnvsError {
  type CloneBoxExecutor (line 61) | pub trait CloneBoxExecutor {
    method clone_box (line 62) | fn clone_box(&self) -> Box<dyn Executor>;
    method clone_box (line 98) | fn clone_box(&self) -> Box<dyn Executor> {
  type Executor (line 65) | pub trait Executor: CloneBoxExecutor {
    method exec (line 67) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError>;
    method validate (line 73) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError>;
    method setup_envs (line 81) | fn setup_envs(&self, envs: HashMap<String, String>) -> Result<(), Exec...
  method clone (line 104) | fn clone(&self) -> Self {

FILE: crates/libcontainer/tests/as_sibling.rs
  function prepare_container_root (line 18) | fn prepare_container_root(root: impl AsRef<Path>) -> Result<()> {
  function hash (line 39) | fn hash(v: impl Hash) -> u64 {
  type SomeExecutor (line 46) | struct SomeExecutor;
  method setup_envs (line 49) | fn setup_envs(&self, _: HashMap<String, String>) -> Result<(), ExecutorS...
  method validate (line 53) | fn validate(&self, _: &Spec) -> Result<(), ExecutorValidationError> {
  method exec (line 57) | fn exec(&self, _: &Spec) -> Result<(), ExecutorError> {
  function run_init_process_as_child (line 64) | fn run_init_process_as_child() -> Result<()> {
  function run_init_process_as_sibling (line 91) | fn run_init_process_as_sibling() -> Result<()> {

FILE: crates/liboci-cli/src/checkpoint.rs
  type Checkpoint (line 9) | pub struct Checkpoint {

FILE: crates/liboci-cli/src/create.rs
  type Create (line 9) | pub struct Create {

FILE: crates/liboci-cli/src/delete.rs
  type Delete (line 5) | pub struct Delete {

FILE: crates/liboci-cli/src/events.rs
  type Events (line 5) | pub struct Events {

FILE: crates/liboci-cli/src/exec.rs
  type Exec (line 9) | pub struct Exec {
  function parse_env (line 67) | fn parse_env<T, U>(s: &str) -> Result<(T, U), Box<dyn Error + Send + Syn...
  function parse_user (line 80) | fn parse_user<T, U>(s: &str) -> Result<(T, Option<U>), Box<dyn Error + S...

FILE: crates/liboci-cli/src/features.rs
  type Features (line 9) | pub struct Features {}

FILE: crates/liboci-cli/src/info.rs
  type Info (line 5) | pub struct Info {}

FILE: crates/liboci-cli/src/kill.rs
  type Kill (line 5) | pub struct Kill {

FILE: crates/liboci-cli/src/lib.rs
  type StandardCmd (line 50) | pub enum StandardCmd {
  type CommonCmd (line 63) | pub enum CommonCmd {
  type GlobalOpts (line 81) | pub struct GlobalOpts {

FILE: crates/liboci-cli/src/list.rs
  type List (line 5) | pub struct List {

FILE: crates/liboci-cli/src/pause.rs
  type Pause (line 5) | pub struct Pause {

FILE: crates/liboci-cli/src/ps.rs
  type Ps (line 5) | pub struct Ps {

FILE: crates/liboci-cli/src/resume.rs
  type Resume (line 5) | pub struct Resume {

FILE: crates/liboci-cli/src/run.rs
  type Run (line 7) | pub struct Run {

FILE: crates/liboci-cli/src/spec.rs
  type Spec (line 7) | pub struct Spec {

FILE: crates/liboci-cli/src/start.rs
  type Start (line 5) | pub struct Start {

FILE: crates/liboci-cli/src/state.rs
  type State (line 5) | pub struct State {

FILE: crates/liboci-cli/src/update.rs
  type Update (line 7) | pub struct Update {

FILE: crates/youki/build.rs
  function main (line 4) | pub fn main() -> Result<()> {

FILE: crates/youki/src/commands/checkpoint.rs
  function checkpoint (line 9) | pub fn checkpoint(args: Checkpoint, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/completion.rs
  type Completion (line 9) | pub struct Completion {
  function completion (line 14) | pub fn completion(args: Completion, app: &mut Command) -> Result<()> {

FILE: crates/youki/src/commands/create.rs
  function create (line 16) | pub fn create(args: Create, root_path: PathBuf, systemd_cgroup: bool) ->...

FILE: crates/youki/src/commands/delete.rs
  function delete (line 8) | pub fn delete(args: Delete, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/events.rs
  function events (line 8) | pub fn events(args: Events, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/exec.rs
  function exec (line 11) | pub fn exec(args: Exec, root_path: PathBuf) -> Result<i32> {

FILE: crates/youki/src/commands/features.rs
  function query_caps (line 11) | fn query_caps() -> Result<Vec<String>> {
  function query_supported_namespaces (line 16) | fn query_supported_namespaces() -> Result<Vec<LinuxNamespaceType>> {
  function known_hooks (line 30) | fn known_hooks() -> Vec<String> {
  function features (line 45) | pub fn features(_: Features) -> Result<()> {
  function test_features (line 114) | fn test_features() {

FILE: crates/youki/src/commands/info.rs
  type Info (line 15) | pub struct Info {}
  function info (line 17) | pub fn info(_: Info) -> Result<()> {
  function print_youki (line 34) | pub fn print_youki() {
  function print_kernel (line 54) | pub fn print_kernel() {
  function print_os (line 75) | pub fn print_os() {
  function try_read_os_from (line 86) | fn try_read_os_from<P: AsRef<Path>>(path: P) -> Option<String> {
  function find_parameter (line 115) | fn find_parameter<'a>(content: &'a str, param_name: &str) -> Option<&'a ...
  function print_hardware (line 123) | pub fn print_hardware() {
  function print_cgroups (line 138) | pub fn print_cgroups() {
  function print_cgroups_setup (line 145) | pub fn print_cgroups_setup() {
  function print_cgroup_mounts (line 152) | pub fn print_cgroup_mounts() {
  function print_cgroup_v2_controllers (line 174) | pub fn print_cgroup_v2_controllers() {
  function read_kernel_config (line 203) | fn read_kernel_config() -> Option<String> {
  function print_namespaces (line 216) | pub fn print_namespaces() {
  function is_cap_available (line 249) | fn is_cap_available(caps: &caps::CapsHashSet, cap: caps::Capability) -> ...
  function print_capabilities (line 257) | pub fn print_capabilities() {
  function print_feature_status (line 280) | fn print_feature_status(config: &str, feature: &str, display: FeatureDis...
  type FeatureDisplay (line 294) | struct FeatureDisplay<'a> {
  function new (line 301) | fn new(name: &'a str) -> Self {
  function with_status (line 309) | fn with_status(name: &'a str, enabled: &'a str, disabled: &'a str) -> Se...

FILE: crates/youki/src/commands/kill.rs
  function kill (line 12) | pub fn kill(args: Kill, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/list.rs
  function list (line 15) | pub fn list(_: List, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/mod.rs
  function construct_container_root (line 27) | fn construct_container_root<P: AsRef<Path>>(root_path: P, container_id: ...
  function load_container (line 40) | fn load_container<P: AsRef<Path>>(root_path: P, container_id: &str) -> R...
  function container_exists (line 50) | fn container_exists<P: AsRef<Path>>(root_path: P, container_id: &str) ->...
  function create_cgroup_manager (line 55) | fn create_cgroup_manager<P: AsRef<Path>>(

FILE: crates/youki/src/commands/pause.rs
  function pause (line 14) | pub fn pause(args: Pause, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/ps.rs
  function ps (line 10) | pub fn ps(args: Ps, root_path: PathBuf) -> Result<()> {
  function get_pid_index (line 51) | fn get_pid_index(title: &str) -> Result<usize> {

FILE: crates/youki/src/commands/resume.rs
  function resume (line 14) | pub fn resume(args: Resume, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/run.rs
  function run (line 14) | pub fn run(args: Run, root_path: PathBuf, systemd_cgroup: bool) -> Resul...
  function handle_foreground (line 55) | fn handle_foreground(init_pid: Pid) -> Result<i32> {
  function test_foreground_forward_sig (line 130) | fn test_foreground_forward_sig() -> Result<()> {
  function test_foreground_exit (line 190) | fn test_foreground_exit() -> Result<()> {

FILE: crates/youki/src/commands/spec_json.rs
  function get_default (line 13) | pub fn get_default() -> Result<Spec> {
  function get_rootless (line 17) | pub fn get_rootless(syscall: &dyn Syscall) -> Result<Spec> {
  function spec (line 89) | pub fn spec(args: liboci_cli::Spec, syscall: &dyn Syscall) -> Result<()> {
  function test_spec_json (line 114) | fn test_spec_json() -> Result<()> {

FILE: crates/youki/src/commands/start.rs
  function start (line 10) | pub fn start(args: Start, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/state.rs
  function state (line 8) | pub fn state(args: State, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/commands/update.rs
  function update (line 12) | pub fn update(args: Update, root_path: PathBuf) -> Result<()> {

FILE: crates/youki/src/main.rs
  type YoukiExtendOpts (line 18) | struct YoukiExtendOpts {
  type Opts (line 33) | struct Opts {
  type SubCommand (line 51) | enum SubCommand {
  function main (line 65) | fn main() -> Result<()> {

FILE: crates/youki/src/observability.rs
  constant LOG_FORMAT_TEXT (line 10) | const LOG_FORMAT_TEXT: &str = "text";
  constant LOG_FORMAT_JSON (line 11) | const LOG_FORMAT_JSON: &str = "json";
  type LogFormat (line 12) | enum LogFormat {
  constant DEFAULT_LOG_LEVEL (line 19) | const DEFAULT_LOG_LEVEL: &str = "debug";
  constant DEFAULT_LOG_LEVEL (line 23) | const DEFAULT_LOG_LEVEL: &str = "error";
  function detect_log_format (line 25) | fn detect_log_format(log_format: Option<&str>) -> Result<LogFormat> {
  function detect_log_level (line 33) | fn detect_log_level(input: Option<String>, is_debug: bool) -> Result<Lev...
  type ObservabilityConfig (line 47) | pub struct ObservabilityConfig {
    method from (line 57) | fn from(opts: &crate::Opts) -> Self {
  function init (line 68) | pub fn init<T>(config: T) -> Result<()>
  function test_detect_log_level (line 179) | fn test_detect_log_level() {
  function test_detect_log_level_default (line 203) | fn test_detect_log_level_default() {
  function test_init_many_times (line 218) | fn test_init_many_times() -> Result<()> {
  function test_higher_loglevel_no_log (line 237) | fn test_higher_loglevel_no_log() -> Result<()> {
  function test_json_logfile (line 281) | fn test_json_logfile() -> Result<()> {

FILE: crates/youki/src/rootpath.rs
  function determine (line 9) | pub fn determine(
  function get_default_not_rootless_path (line 61) | fn get_default_not_rootless_path() -> PathBuf {
  function get_default_not_rootless_path (line 66) | fn get_default_not_rootless_path() -> PathBuf {
  function get_default_rootless_path (line 71) | fn get_default_rootless_path(uid: libc::uid_t) -> PathBuf {
  function get_default_rootless_path (line 76) | fn get_default_rootless_path(uid: libc::uid_t) -> PathBuf {
  function test_user_specified (line 94) | fn test_user_specified() -> Result<()> {
  function test_user_specified_exists (line 109) | fn test_user_specified_exists() -> Result<()> {
  function test_determine_root_path_non_rootless (line 124) | fn test_determine_root_path_non_rootless() -> Result<()> {
  function test_determine_root_path_rootless (line 152) | fn test_determine_root_path_rootless() -> Result<()> {

FILE: crates/youki/src/workload/executor.rs
  type DefaultExecutor (line 5) | pub struct DefaultExecutor {}
  method exec (line 8) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
  method validate (line 33) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError> {
  function default_executor (line 57) | pub fn default_executor() -> DefaultExecutor {

FILE: crates/youki/src/workload/wasmedge.rs
  constant EXECUTOR_NAME (line 9) | const EXECUTOR_NAME: &str = "wasmedge";
  type WasmedgeExecutor (line 12) | pub struct WasmedgeExecutor {}
  method exec (line 15) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
  method validate (line 62) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError> {
  function get_executor (line 71) | pub fn get_executor() -> WasmedgeExecutor {
  function can_handle (line 75) | fn can_handle(spec: &Spec) -> bool {
  function get_args (line 89) | fn get_args(spec: &Spec) -> &[String] {
  function env_to_wasi (line 101) | fn env_to_wasi(spec: &Spec) -> Vec<String> {

FILE: crates/youki/src/workload/wasmer.rs
  constant EXECUTOR_NAME (line 8) | const EXECUTOR_NAME: &str = "wasmer";
  type WasmerExecutor (line 11) | pub struct WasmerExecutor {}
  method exec (line 14) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
  method validate (line 93) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError> {
  function get_executor (line 102) | pub fn get_executor() -> WasmerExecutor {
  function can_handle (line 106) | fn can_handle(spec: &Spec) -> bool {
  function test_can_handle_oci_handler (line 130) | fn test_can_handle_oci_handler() -> Result<()> {
  function test_can_handle_compat_wasm_spec (line 144) | fn test_can_handle_compat_wasm_spec() -> Result<()> {
  function test_can_handle_no_execute (line 158) | fn test_can_handle_no_execute() -> Result<()> {

FILE: crates/youki/src/workload/wasmtime.rs
  constant EXECUTOR_NAME (line 7) | const EXECUTOR_NAME: &str = "wasmtime";
  type WasmtimeExecutor (line 10) | pub struct WasmtimeExecutor {}
  method exec (line 13) | fn exec(&self, spec: &Spec) -> Result<(), ExecutorError> {
  method validate (line 99) | fn validate(&self, spec: &Spec) -> Result<(), ExecutorValidationError> {
  function get_executor (line 108) | pub fn get_executor() -> WasmtimeExecutor {
  function can_handle (line 112) | fn can_handle(spec: &Spec) -> bool {

FILE: experiment/seccomp/src/instruction/arch.rs
  type Arch (line 5) | pub enum Arch {
  function gen_validate (line 9) | pub fn gen_validate(arc: &Arch) -> Vec<Instruction> {
  function test_gen_validate_x86 (line 27) | fn test_gen_validate_x86() {
  function test_gen_validate_aarch64 (line 35) | fn test_gen_validate_aarch64() {

FILE: experiment/seccomp/src/instruction/consts.rs
  constant BPF_LD (line 6) | pub const BPF_LD: u16 = 0x00;
  constant BPF_ALU (line 8) | pub const BPF_ALU: u16 = 0x04;
  constant BPF_JMP (line 10) | pub const BPF_JMP: u16 = 0x05;
  constant BPF_RET (line 12) | pub const BPF_RET: u16 = 0x06;
  constant BPF_W (line 17) | pub const BPF_W: u16 = 0x00;
  constant BPF_ABS (line 19) | pub const BPF_ABS: u16 = 0x20;
  constant BPF_AND (line 23) | pub const BPF_AND: u16 = 0x50;
  constant BPF_JA (line 28) | pub const BPF_JA: u16 = 0x00;
  constant BPF_JEQ (line 30) | pub const BPF_JEQ: u16 = 0x10;
  constant BPF_JGT (line 31) | pub const BPF_JGT: u16 = 0x20;
  constant BPF_JGE (line 32) | pub const BPF_JGE: u16 = 0x30;
  constant BPF_K (line 34) | pub const BPF_K: u16 = 0x00;
  constant SECCOMP_RET_ALLOW (line 38) | pub const SECCOMP_RET_ALLOW: u32 = 0x7fff_0000;
  constant SECCOMP_RET_ERRNO (line 39) | pub const SECCOMP_RET_ERRNO: u32 = 0x0005_0000;
  constant SECCOMP_RET_KILL_THREAD (line 40) | pub const SECCOMP_RET_KILL_THREAD: u32 = 0x0000_0000;
  constant SECCOMP_RET_KILL_PROCESS (line 41) | pub const SECCOMP_RET_KILL_PROCESS: u32 = 0x8000_0000;
  constant SECCOMP_RET_LOG (line 42) | pub const SECCOMP_RET_LOG: u32 = 0x7ffc_0000;
  constant SECCOMP_RET_TRACE (line 43) | pub const SECCOMP_RET_TRACE: u32 = 0x7ff0_0000;
  constant SECCOMP_RET_TRAP (line 44) | pub const SECCOMP_RET_TRAP: u32 = 0x0003_0000;
  constant SECCOMP_RET_MASK (line 45) | pub const SECCOMP_RET_MASK: u32 = 0x0000_ffff;
  constant SECCOMP_RET_USER_NOTIF (line 46) | pub const SECCOMP_RET_USER_NOTIF: u32 = 0x7fc00000;
  constant AUDIT_ARCH_X86_64 (line 50) | pub const AUDIT_ARCH_X86_64: u32 = 62 | 0x8000_0000 | 0x4000_0000;
  constant AUDIT_ARCH_AARCH64 (line 51) | pub const AUDIT_ARCH_AARCH64: u32 = 183 | 0x8000_0000 | 0x4000_0000;
  type SeccompData (line 63) | struct SeccompData {
  function seccomp_data_arch_offset (line 70) | pub const fn seccomp_data_arch_offset() -> u8 {
  function seccomp_data_arg_size (line 74) | pub const fn seccomp_data_arg_size() -> u8 {
  function seccomp_data_args_offset (line 78) | pub const fn seccomp_data_args_offset() -> u8 {
  constant SECCOMP_IOC_MAGIC (line 82) | pub const SECCOMP_IOC_MAGIC: u8 = b'!';
  function test_seccomp_data_arch_offset (line 89) | fn test_seccomp_data_arch_offset() {
  function test_seccomp_data_arg_size_offset (line 96) | fn test_seccomp_data_arg_size_offset() {
  function test_seccomp_data_args_offset (line 103) | fn test_seccomp_data_args_offset() {

FILE: experiment/seccomp/src/instruction/inst.rs
  type Instruction (line 7) | pub struct Instruction {
    method new (line 15) | fn new(
    method jump (line 29) | pub fn jump(
    method stmt (line 38) | pub fn stmt(code: c_ushort, k: c_uint) -> Self {
  function test_bpf_instructions (line 49) | fn test_bpf_instructions() {

FILE: experiment/seccomp/src/main.rs
  function send_fd (line 25) | fn send_fd<F: AsRawFd>(sock: OwnedFd, fd: &F) -> nix::Result<()> {
  function recv_fd (line 35) | fn recv_fd<F: FromRawFd>(sock: RawFd) -> nix::Result<Option<F>> {
  function handle_notifications (line 50) | async fn handle_notifications(notify_fd: NotifyFd) -> nix::Result<()> {
  function handle_signal (line 64) | async fn handle_signal(pid: nix::unistd::Pid) -> Result<()> {
  function main (line 83) | async fn main() -> Result<()> {

FILE: experiment/seccomp/src/seccomp.rs
  type SeccompError (line 22) | pub enum SeccompError {
  type Seccomp (line 27) | pub struct Seccomp {
    method new (line 38) | pub fn new() -> Self {
    method apply (line 45) | pub fn apply(&self) -> Result<NotifyFd, SeccompError> {
  method default (line 32) | fn default() -> Self {
  type NotifyFd (line 66) | pub struct NotifyFd {
    method success (line 96) | pub fn success(&self, v: i64, notify_id: u64) -> nix::Result<()> {
    method recv (line 183) | pub fn recv(&self) -> nix::Result<Notification> {
  method drop (line 71) | fn drop(&mut self) {
  method from_raw_fd (line 77) | unsafe fn from_raw_fd(fd: RawFd) -> Self {
  method into_raw_fd (line 83) | fn into_raw_fd(self) -> RawFd {
  method as_raw_fd (line 90) | fn as_raw_fd(&self) -> RawFd {
  type SeccompData (line 113) | pub struct SeccompData {
  type SeccompNotif (line 122) | pub struct SeccompNotif {
  type SeccompNotifResp (line 131) | pub struct SeccompNotifResp {
  type SeccompNotifSizes (line 140) | pub struct SeccompNotifSizes {
  type SeccompNotifAddfd (line 148) | pub struct SeccompNotifAddfd {
  type Notification (line 171) | pub struct Notification<'f> {
  function fmt (line 177) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function seccomp (line 194) | unsafe fn seccomp(op: c_uint, flags: c_ulong, args: *mut c_void) -> c_lo...
  type Filters (line 199) | struct Filters {
  function get_syscall_number (line 204) | fn get_syscall_number(arc: &Arch, name: &str) -> Option<u64> {
  type InstructionData (line 222) | pub struct InstructionData {
  function from (line 229) | fn from(inst_data: InstructionData) -> Self {
  type Rule (line 242) | pub struct Rule {
    method new (line 250) | pub fn new(syscall: String, arg_cnt: u8, args: SyscallArgs, is_notify:...
    method to_instruction (line 259) | pub fn to_instruction(arch: &Arch, action: u32, rule: &Rule) -> Vec<In...
  function test_get_syscall_number_x86 (line 284) | fn test_get_syscall_number_x86() {
  function test_get_syscall_number_aarch64 (line 290) | fn test_get_syscall_number_aarch64() {
  function test_to_instruction_x86 (line 296) | fn test_to_instruction_x86() {
  function test_to_instruction_aarch64 (line 310) | fn test_to_instruction_aarch64() {

FILE: experiment/selinux/src/main.rs
  function main (line 6) | fn main() -> Result<(), SELinuxError> {

FILE: experiment/selinux/src/selinux.rs
  type SELinuxMode (line 15) | pub enum SELinuxMode {
    method from (line 25) | fn from(mode: i32) -> Self {
    method from (line 36) | fn from(mode: &str) -> Self {
    method fmt (line 46) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  constant ERR_EMPTY_PATH (line 56) | pub(crate) const ERR_EMPTY_PATH: &str = "empty path";
  constant SELINUX_FS_MOUNT (line 57) | const SELINUX_FS_MOUNT: &str = "/sys/fs/selinux";
  constant CONTEXT_FILE (line 58) | const CONTEXT_FILE: &str = "/usr/share/containers/selinux/contexts";
  constant SELINUX_TYPE_TAG (line 59) | const SELINUX_TYPE_TAG: &str = "SELINUXTYPE";
  constant SELINUX_TAG (line 60) | const SELINUX_TAG: &str = "SELINUX";
  constant SELINUX_DIR (line 61) | const SELINUX_DIR: &str = "/etc/selinux/";
  constant SELINUX_CONFIG (line 62) | const SELINUX_CONFIG: &str = "config";
  type SELinuxError (line 65) | pub enum SELinuxError {
  type SELinux (line 96) | pub struct SELinux {
    method new (line 127) | pub fn new() -> Self {
    method policy_root (line 150) | fn policy_root(&mut self) -> Option<&PathBuf> {
    method get_config_key (line 161) | fn get_config_key(&mut self, target_key: &str) -> Result<String, SELin...
    method get_enabled (line 195) | pub fn get_enabled(&mut self) -> bool {
    method verify_selinux_fs_mount (line 214) | fn verify_selinux_fs_mount<P: AsRef<Path>>(mnt: P) -> bool {
    method check_line_include_selinux_fs_mount_point (line 236) | fn check_line_include_selinux_fs_mount_point(line: &str) -> Option<Pat...
    method find_selinux_fs (line 252) | fn find_selinux_fs() -> Option<PathBuf> {
    method get_selinux_mountpoint (line 287) | pub fn get_selinux_mountpoint(&mut self) -> Option<&PathBuf> {
    method class_index (line 298) | pub fn class_index(&mut self, class: &str) -> Result<i64, SELinuxError> {
    method open_context_file (line 315) | pub(crate) fn open_context_file(&mut self) -> Result<File, SELinuxErro...
    method selinux_enforce_path (line 334) | fn selinux_enforce_path(&mut self) -> Option<PathBuf> {
    method enforce_mode (line 340) | pub fn enforce_mode(&mut self) -> SELinuxMode {
    method is_mls_enabled (line 352) | pub fn is_mls_enabled(&mut self) -> bool {
    method set_enforce_mode (line 365) | pub fn set_enforce_mode(&mut self, mode: SELinuxMode) -> Result<(), SE...
    method default_enforce_mode (line 376) | pub fn default_enforce_mode(&mut self) -> SELinuxMode {
    method write_con (line 385) | pub fn write_con<P: AsRef<Path>>(
    method is_proc_handle (line 415) | pub fn is_proc_handle(file: &File) -> Result<(), SELinuxError> {
    method read_con_fd (line 438) | pub fn read_con_fd<F: AsFd + Read>(file: &mut F) -> Result<String, SEL...
    method read_con (line 449) | pub fn read_con<P: AsRef<Path>>(fpath: P) -> Result<String, SELinuxErr...
    method attr_path (line 463) | pub fn attr_path(&self, attr: &str) -> PathBuf {
  method default (line 121) | fn default() -> Self {
  function create_temp_file (line 490) | fn create_temp_file(content: &[u8], file_name: &str) {
  function test_read_con_fd (line 498) | fn test_read_con_fd() {
  function test_attr_path (line 516) | fn test_attr_path() {
  function test_is_proc_handle (line 536) | fn test_is_proc_handle() {
  function test_check_line_include_selinux_fs_mount_point (line 560) | fn test_check_line_include_selinux_fs_mount_point() {

FILE: experiment/selinux/src/selinux_label.rs
  constant XATTR_NAME_SELINUX (line 11) | const XATTR_NAME_SELINUX: &str = "security.selinux";
  constant KEY_LABEL_PATH (line 12) | const KEY_LABEL_PATH: &str = "/proc/self/attr/keycreate";
  type SELinuxLabel (line 15) | pub struct SELinuxLabel {
    method fmt (line 23) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    type Error (line 32) | type Error = SELinuxError;
    method try_from (line 33) | fn try_from(label: String) -> Result<Self, SELinuxError> {
  method set_file_label (line 65) | pub fn set_file_label<P: AsRef<Path> + PathXattr>(
  method lset_file_label (line 89) | pub fn lset_file_label<P: AsRef<Path> + PathXattr>(
  method file_label (line 113) | pub fn file_label<P: AsRef<Path> + PathXattr>(fpath: P) -> Result<SELinu...
  method lfile_label (line 126) | pub fn lfile_label<P: AsRef<Path> + PathXattr>(fpath: P) -> Result<SELin...
  method set_fscreate_label (line 139) | pub fn set_fscreate_label(&mut self, label: SELinuxLabel) -> Result<usiz...
  method fscreate_label (line 149) | pub fn fscreate_label(&self) -> Result<SELinuxLabel, SELinuxError> {
  method pid_label (line 155) | pub fn pid_label(pid: i64) -> Result<SELinuxLabel, SELinuxError> {
  method exec_label (line 164) | pub fn exec_label(&self) -> Result<SELinuxLabel, SELinuxError> {
  method set_exec_label (line 171) | pub fn set_exec_label(&mut self, label: SELinuxLabel) -> Result<usize, S...
  method set_task_label (line 181) | pub fn set_task_label(&mut self, label: SELinuxLabel) -> Result<usize, S...
  method set_socket_label (line 191) | pub fn set_socket_label(&mut self, label: SELinuxLabel) -> Result<usize,...
  method socket_label (line 200) | pub fn socket_label(&self) -> Result<SELinuxLabel, SELinuxError> {
  method current_label (line 206) | pub fn current_label(&self) -> Result<SELinuxLabel, SELinuxError> {
  method peer_label (line 212) | pub fn peer_label<F: AsFd>(fd: F) -> Result<SELinuxLabel, SELinuxError> {
  method set_key_label (line 226) | pub fn set_key_label(&mut self, label: SELinuxLabel) -> Result<usize, SE...
  method key_label (line 231) | pub fn key_label() -> Result<SELinuxLabel, SELinuxError> {
  method kvm_container_labels (line 238) | pub fn kvm_container_labels(&mut self) -> (Option<SELinuxLabel>, Option<...
  method init_container_labels (line 247) | pub fn init_container_labels(&mut self) -> (Option<SELinuxLabel>, Option...
  method container_labels (line 256) | pub fn container_labels(&mut self) -> (Option<SELinuxLabel>, Option<SELi...
  method label (line 278) | fn label(&mut self, key: &str) -> Option<SELinuxLabel> {
  method load_labels (line 287) | fn load_labels(&mut self) {
  method format_mount_label (line 322) | pub fn format_mount_label(src: &str, mount_label: &str) -> String {
  method format_mount_label_by_type (line 330) | pub fn format_mount_label_by_type(src: &str, mount_label: &str, context_...
  function test_format_mount_label (line 349) | fn test_format_mount_label() {
  function test_format_mount_label_by_type (line 361) | fn test_format_mount_label_by_type() {

FILE: experiment/selinux/src/tools/sockopt.rs
  type PeerSec (line 7) | pub struct PeerSec;
  type Val (line 14) | type Val = CString;
  method get (line 16) | fn get<F: AsFd>(&self, fd: &F) -> nix::Result<Self::Val> {

FILE: experiment/selinux/src/tools/xattr.rs
  type XattrError (line 6) | pub enum XattrError {
  constant INITIAL_BUF_SIZE (line 20) | const INITIAL_BUF_SIZE: usize = 1024;
  type PathXattr (line 22) | pub trait PathXattr {
    method set_xattr (line 23) | fn set_xattr(&self, attr: &str, data: &[u8]) -> Result<(), XattrError>;
    method lset_xattr (line 24) | fn lset_xattr(&self, attr: &str, data: &[u8]) -> Result<(), XattrError>;
    method get_xattr (line 25) | fn get_xattr(&self, attr: &str) -> Result<String, XattrError>;
    method lget_xattr (line 26) | fn lget_xattr(&self, attr: &str) -> Result<String, XattrError>;
    method set_xattr (line 35) | fn set_xattr(&self, attr: &str, data: &[u8]) -> Result<(), XattrError> {
    method lset_xattr (line 55) | fn lset_xattr(&self, attr: &str, data: &[u8]) -> Result<(), XattrError> {
    method get_xattr (line 75) | fn get_xattr(&self, attr: &str) -> Result<String, XattrError> {
    method lget_xattr (line 101) | fn lget_xattr(&self, attr: &str) -> Result<String, XattrError> {
  function test_set_xattr_and_get_xattr (line 132) | fn test_set_xattr_and_get_xattr() {

FILE: tests/contest/contest/src/logger.rs
  constant LOG_LEVEL_ENV_NAME (line 7) | const LOG_LEVEL_ENV_NAME: &str = "YOUKI_INTEGRATION_LOG_LEVEL";
  function init (line 12) | pub fn init(debug: bool) -> Result<()> {
  function detect_log_level (line 19) | fn detect_log_level(is_debug: bool) -> Result<LevelFilter> {

FILE: tests/contest/contest/src/main.rs
  type Opts (line 62) | struct Opts {
  type SubCommand (line 72) | enum SubCommand {
  type Run (line 80) | struct Run {
  function parse_tests (line 95) | fn parse_tests(tests: &[String]) -> Vec<(&str, Option<Vec<&str>>)> {
  function main (line 109) | fn main() -> Result<()> {
  function get_abs_path (line 240) | fn get_abs_path(rel_path: &Path) -> PathBuf {
  function run (line 255) | fn run(opts: Run, test_manager: &TestManager) -> Result<()> {
  function list (line 272) | fn list(test_manager: &TestManager) -> Result<()> {

FILE: tests/contest/contest/src/tests/cgroups/blkio.rs
  type WeightDevice (line 26) | struct WeightDevice {
  type ThrottleDevice (line 34) | struct ThrottleDevice {
  type BlockIO (line 41) | struct BlockIO {
  function can_run (line 51) | fn can_run() -> bool {
  function supports_weight (line 55) | fn supports_weight() -> bool {
  function supports_weight_devices (line 59) | fn supports_weight_devices() -> bool {
  function supports_throttle_bps (line 65) | fn supports_throttle_bps() -> bool {
  function supports_throttle_iops (line 69) | fn supports_throttle_iops() -> bool {
  function parse_device_data (line 73) | fn parse_device_data<'a>(device_type: &'static str, line: &'a str) -> Re...
  function create_spec (line 91) | fn create_spec(cgroup_name: &str, block_io: LinuxBlockIo) -> Result<Spec> {
  function get_blkio_data (line 112) | fn get_blkio_data(path: &Path) -> Result<BlockIO> {
  function validate_block_io (line 288) | fn validate_block_io(cgroup_name: &str, spec: &Spec) -> Result<()> {
  function test_blkio (line 479) | fn test_blkio(test_name: &str, rate: u64, empty: bool) -> TestResult {
  function get_test_group (line 562) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/cpu/mod.rs
  function create_cpu_spec (line 12) | fn create_cpu_spec(
  function create_spec (line 44) | fn create_spec(cgroup_name: &str, case: LinuxCpu) -> Result<Spec> {
  function create_empty_spec (line 64) | fn create_empty_spec(cgroup_name: &str) -> Result<Spec> {

FILE: tests/contest/contest/src/tests/cgroups/cpu/v1.rs
  constant CPU_CGROUP_PREFIX (line 11) | const CPU_CGROUP_PREFIX: &str = "/sys/fs/cgroup/cpu,cpuacct";
  constant DEFAULT_REALTIME_PERIOD (line 12) | const DEFAULT_REALTIME_PERIOD: u64 = 1000000;
  constant DEFAULT_REALTIME_RUNTIME (line 13) | const DEFAULT_REALTIME_RUNTIME: i64 = 950000;
  function get_realtime_period (line 15) | fn get_realtime_period() -> Option<u64> {
  function get_realtime_runtime (line 25) | fn get_realtime_runtime() -> Option<i64> {
  function test_cpu_cgroups (line 35) | fn test_cpu_cgroups() -> TestResult {
  function test_empty_cpu (line 222) | fn test_empty_cpu() -> TestResult {
  function test_cpu_idle_set (line 233) | fn test_cpu_idle_set() -> TestResult {
  function test_cpu_idle_default (line 259) | fn test_cpu_idle_default() -> TestResult {
  function can_run (line 282) | fn can_run() -> bool {
  function can_run_idle (line 286) | fn can_run_idle() -> bool {
  function get_test_group (line 295) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/cpu/v2.rs
  constant DEFAULT_PERIOD (line 17) | const DEFAULT_PERIOD: u64 = 100_000;
  constant CPU (line 18) | const CPU: &str = "cpu";
  constant CGROUP_CPU_IDLE (line 19) | const CGROUP_CPU_IDLE: &str = "cpu.idle";
  function test_cpu_idle_set (line 30) | fn test_cpu_idle_set() -> TestResult {
  function test_cpu_idle_default (line 48) | fn test_cpu_idle_default() -> TestResult {
  function test_cpu_weight_valid_set (line 61) | fn test_cpu_weight_valid_set() -> TestResult {
  function test_cpu_weight_zero_ignored (line 83) | fn test_cpu_weight_zero_ignored() -> TestResult {
  function test_cpu_weight_too_high_maximum_set (line 107) | fn test_cpu_weight_too_high_maximum_set() -> TestResult {
  function test_cpu_quota_valid_set (line 133) | fn test_cpu_quota_valid_set() -> TestResult {
  function test_cpu_quota_zero_default_set (line 155) | fn test_cpu_quota_zero_default_set() -> TestResult {
  function test_cpu_quota_negative_default_set (line 177) | fn test_cpu_quota_negative_default_set() -> TestResult {
  function test_cpu_period_valid_set (line 207) | fn test_cpu_period_valid_set() -> TestResult {
  function test_cpu_quota_period_unspecified_unchanged (line 248) | fn test_cpu_quota_period_unspecified_unchanged() -> TestResult {
  function test_cpu_period_and_quota_valid_set (line 271) | fn test_cpu_period_and_quota_valid_set() -> TestResult {
  function check_cpu_weight (line 295) | fn check_cpu_weight(cgroup_name: &str, expected_weight: u64) -> Result<(...
  function check_cpu_idle (line 304) | fn check_cpu_idle(cgroup_name: &str, expected_value: i64) -> Result<()> {
  function check_cpu_max (line 313) | fn check_cpu_max(cgroup_name: &str, expected_quota: i64, expected_period...
  function read_cgroup_data (line 345) | fn read_cgroup_data(cgroup_name: &str, cgroup_file: &str) -> Result<Stri...
  function prepare_cpu_max (line 362) | fn prepare_cpu_max(spec: &Spec, quota: &str, period: &str) -> Result<()> {
  function can_run (line 381) | fn can_run() -> bool {
  function can_run_idle (line 410) | fn can_run_idle() -> bool {
  function get_test_group (line 417) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/memory.rs
  constant CGROUP_MEMORY_LIMIT (line 12) | const CGROUP_MEMORY_LIMIT: &str = "/sys/fs/cgroup/memory/memory.limit_in...
  constant CGROUP_MEMORY_SWAPPINESS (line 13) | const CGROUP_MEMORY_SWAPPINESS: &str = "/sys/fs/cgroup/memory/memory.swa...
  function create_spec (line 15) | fn create_spec(cgroup_name: &str, limit: i64, swappiness: u64) -> Result...
  function test_memory_cgroups (line 41) | fn test_memory_cgroups() -> TestResult {
  function can_run (line 67) | fn can_run() -> bool {
  function get_test_group (line 71) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/mod.rs
  function cleanup_v1 (line 13) | pub fn cleanup_v1() -> Result<()> {
  function cleanup_v2 (line 25) | pub fn cleanup_v2() -> Result<()> {
  function list_subsystem_mount_points (line 43) | pub fn list_subsystem_mount_points() -> Result<Vec<PathBuf>> {
  function attach_controller (line 59) | pub fn attach_controller(cgroup_root: &Path, cgroup_path: &Path, control...
  function write_controller (line 78) | fn write_controller(cgroup_path: &Path, controller: &str) -> Result<()> {

FILE: tests/contest/contest/src/tests/cgroups/network/absolute_network.rs
  function create_spec (line 15) | fn create_spec(
  function get_network_interfaces (line 68) | fn get_network_interfaces() -> Option<(String, String)> {
  function test_network_cgroups (line 76) | fn test_network_cgroups() -> TestResult {
  function can_run (line 140) | fn can_run() -> bool {
  function get_test_group (line 150) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/network/mod.rs
  function check_network_cgroup_paths (line 14) | fn check_network_cgroup_paths() -> Result<(&'static str, &'static str)> {
  function validate_network (line 34) | fn validate_network(cgroup_name: &str, spec: &Spec) -> Result<()> {

FILE: tests/contest/contest/src/tests/cgroups/network/relative_network.rs
  function create_spec (line 15) | fn create_spec(cgroup_name: &str, class_id: u32, prio: u32, if_name: &st...
  function get_loopback_interface (line 50) | fn get_loopback_interface() -> Option<String> {
  function test_relative_network_cgroups (line 57) | fn test_relative_network_cgroups() -> TestResult {
  function can_run (line 72) | fn can_run() -> bool {
  function get_test_group (line 82) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/cgroups/pids.rs
  function create_spec (line 14) | fn create_spec(cgroup_name: &str, limit: i64) -> Result<Spec> {
  function test_positive_limit (line 40) | fn test_positive_limit() -> TestResult {
  function test_zero_limit (line 53) | fn test_zero_limit() -> TestResult {
  function test_negative_limit (line 66) | fn test_negative_limit() -> TestResult {
  function check_pid_limit_set (line 78) | fn check_pid_limit_set(cgroup_name: &str, expected: i64) -> Result<()> {
  function check_pids_are_unlimited (line 118) | fn check_pids_are_unlimited(cgroup_name: &str) -> Result<()> {
  function can_run (line 145) | fn can_run() -> bool {
  function get_test_group (line 149) | pub fn get_test_group() -> TestGroup {

FILE: tests/contest/contest/src/tests/create_runtime/mod.rs
  constant HOOK_OUTPUT_FILE (line 13) | const HOOK_OUTPUT_FILE: &str = "output";
  function get_output_file_path (line 15) | fn get_output_file_path(bundle: &tempfile::TempDir) -> PathBuf {
  function delete_output_file (line 23) | fn delete_output_file(path: &PathBuf) {
  function build_log_hook (line 29) | fn build_log_hook(host_output_file: &str) -> oci_spec::runtime::Hook {
  function get_spec (line 41) | fn get_spec(host_output_file: &str) -> Spec {
  function get_test (line 74) | fn get_test(test_name: &'static str) -> Test {
  function get_create_runtime_tests (line 115) | pub fn get_create_runtime_tests() -> TestGroup {

FILE: tests/contest/contest/src/tests/delete/delete_test.rs
  constant DEFAULT_TIMEOUT (line 9) | const DEFAULT_TIMEOUT: Duration = Duration::from_secs(75);
  function delete_non_existed_container (line 12) | fn delete_non_existed_container() -> TestResult {
  function delete_created_container_test (line 25) | fn delete_created_container_test() -> TestResult {
  function delete_running_container_test (line 52) | fn delete_running_container_test() -> TestResult {
  function delete_stopped_container_test (line 107) | fn delete_stopped_container_test() -> TestResult {
  function get_delete_test (line 156) | pub fn get_delete_test() -> TestGroup {

FILE: tests/contest/contest/src/tests/devices/devices_test.rs
  function create_spec (line 10) | fn create_spec() -> Result<Spec> {
  function devices_test (line 59) | fn devices_test() -> TestResult {
  function create_spec_default_permissions (line 64) | fn create_spec_default_permissions() -> Result<Spec> {
  function devices_default_permissions_test (line 92) | fn devices_default_permissions_test() -> TestResult {
  function get_devices_test (line 97) | pub fn get_devices_test() -> TestGroup {

FILE: tests/contest/contest/src/tests/domainname/mod.rs
  function get_spec (line 7) | fn get_spec(domainname: &str) -> Spec {
  function set_domainname_test (line 23) | fn set_domainname_test() -> TestResult {
  function get_domainname_tests (line 28) | pub fn get_domainname_tests() -> TestGroup {

FILE: tests/contest/contest/src/tests/example/hello_world.rs
  function create_spec (line 9) | fn create_spec() -> Result<Spec> {
  function example_test (line 27) | fn example_test() -> TestResult {
  function get_example_test (line 34) | pub fn get_example_test() -> TestGroup {

FILE: tests/contest/contest/src/tests/exec/mod.rs
  function create_spec (line 7) | fn create_spec(process: Option<ProcessBuilder>) -> Result<Spec> {
  function get_exec_test (line 21) | pub fn get_exec_test() -> TestGroup {

FILE: tests/contest/contest/src/tests/exec/mount_test.rs
  function get_mount_test (line 12) | pub(crate) fn get_mount_test() -> TestResult {

FILE: tests/contest/contest/src/tests/exec_cpu_affinity/exec_cpu_affinity_test.rs
  function create_spec (line 11) | fn create_spec(initial: Option<&str>, fin: Option<&str>) -> Result<Spec> {
  function test_cpu_affinity_only_initial_set_from_process_json (line 33) | fn test_cpu_affinity_only_initial_set_from_process_json() -> TestResult {
  function test_cpu_affinity_initial_and_final_set_from_process_json (line 75) | fn test_cpu_affinity_initial_and_final_set_from_process_json() -> TestRe...
  function test_cpu_affinity_from_config_json (line 128) | fn test_cpu_affinity_from_config_json() -> TestResult {
  function get_exec_cpu_affinity_test (line 169) | pub fn get_exec_cpu_affinity_test() -> TestGroup {
  function create_process (line 193) | pub fn create_process(
  function affinity_mask_from_str (line 229) | fn affinity_mask_from_str(cpuset_str: &str) -> u64 {

FILE: tests/contest/contest/src/tests/exec_env/exec_env_test.rs
  function create_spec_with_env (line 12) | fn create_spec_with_env(env: Vec<String>) -> anyhow::Result<Spec> {
  function test_exec_inherits_spec_env (line 25) | fn test_exec_inherits_spec_env() -> TestResult {
  function test_cli_env_overrides_spec (line 59) | fn test_cli_env_overrides_spec() -> TestResult {
  function test_cli_env_adds_new_var (line 99) | fn test_cli_env_adds_new_var() -> TestResult {
  function test_env_from_process_json (line 141) | fn test_env_from_process_json() -> TestResult {
  function get_exec_env_test (line 196) | pub fn get_exec_env_test() -> TestGroup {

FILE: tests/contest/contest/src/tests/fd_control/mod.rs
  function create_spec (line 10) | fn create_spec() -> Result<Spec> {
  function open_devnull_no_cloexec (line 26) | fn open_devnull_no_cloexec() -> Result<(fs::File, RawFd)> {
  function only_stdio_

[
  {
    "path": ".cargo/config.toml",
    "chars": 35,
    "preview": "[profile.release]\nstrip = \"symbols\""
  },
  {
    "path": ".codecov.yml",
    "chars": 211,
    "preview": "---\ncodecov:\n  notify:\n    after_n_builds: 1\n    require_ci_to_pass: false\n\ncoverage:\n  precision: 2\n  round: down\n  ran"
  },
  {
    "path": ".devcontainer/Dockerfile",
    "chars": 1538,
    "preview": "ARG VARIANT=\"bullseye\"\nFROM mcr.microsoft.com/vscode/devcontainers/rust:1-${VARIANT}\n\n# Install docker with youki\nCOPY <"
  },
  {
    "path": ".devcontainer/devcontainer-lock.json",
    "chars": 667,
    "preview": "{\n  \"features\": {\n    \"ghcr.io/devcontainers/features/common-utils:2\": {\n      \"version\": \"2.5.4\",\n      \"resolved\": \"gh"
  },
  {
    "path": ".devcontainer/devcontainer.json",
    "chars": 618,
    "preview": "{\n\t\"name\": \"Youki\",\n\t\"features\": {\n\t\t\"ghcr.io/devcontainers/features/docker-in-docker:2\": {}\n\t},\n\t\"customizations\": {\n\t\t"
  },
  {
    "path": ".git-blame-ignore-revs",
    "chars": 231,
    "preview": "# Ignore commits in the blame view\n# see:\n#   https://docs.github.com/en/repositories/working-with-files/using-files/vie"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/BUG_REPORT.yml",
    "chars": 1618,
    "preview": "name: Bug Report\ndescription: File a bug report.\ntitle: \"[Bug]: \"\nlabels: [\"kind/bug\"]\nbody:\n  - type: markdown\n    attr"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/FEATURE_REQ.yml",
    "chars": 1475,
    "preview": "name: Feature Request\ndescription: Suggest an idea for this project\ntitle: \"[FEATURE]: \"\nlabels: [\"enhancement\"]\nbody:\n "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/config.yml",
    "chars": 88,
    "preview": "blank_issues_enabled: true # allow people to not use forms, just directly create issues\n"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 244,
    "preview": "version: 2\nupdates:\n  - package-ecosystem: cargo\n    directory: \".\"\n    schedule:\n      interval: daily\n    open-pull-re"
  },
  {
    "path": ".github/grcov.yml",
    "chars": 138,
    "preview": "branch: true\nignore-not-existing: true\nllvm: true\nfilter: covered\noutput-type: lcov\noutput-path: ./lcov.info\nprefix-dir:"
  },
  {
    "path": ".github/pull_request_template.md",
    "chars": 1046,
    "preview": "## Description\n<!-- Provide a clear and concise description of your changes -->\n\n## Type of Change\n<!-- Mark the appropr"
  },
  {
    "path": ".github/release.yml",
    "chars": 508,
    "preview": "changelog:\n  exclude:\n    authors:\n      - dependabot\n  categories:\n    - title: 💪 Improvements\n      labels:\n        - "
  },
  {
    "path": ".github/workflows/basic.yml",
    "chars": 6316,
    "preview": "name: 🔍 Basic Checks\n\non:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n  workflow_dispa"
  },
  {
    "path": ".github/workflows/benchmark_execution_time.yml",
    "chars": 5069,
    "preview": "name: ⏱️ Benchmark execution time comparison with the main branch\n\non:\n  issue_comment:\n    types: [created, edited, del"
  },
  {
    "path": ".github/workflows/dependabot_auto.yaml",
    "chars": 1467,
    "preview": "name: 🤖 Dependabot automation\n\non:\n  pull_request:\n    types:\n      - opened\n\npermissions:\n  pull-requests: write\n  cont"
  },
  {
    "path": ".github/workflows/docs.yaml",
    "chars": 1041,
    "preview": "name: 📓 Deploy the documentation\n\non:\n  push:\n    branches:\n      - main\n\njobs:\n  changes:\n    runs-on: ubuntu-24.04\n   "
  },
  {
    "path": ".github/workflows/e2e.yaml",
    "chars": 8344,
    "preview": "name: 🧪 e2e test\n\non:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n\njobs:\n  youki-build"
  },
  {
    "path": ".github/workflows/integration_tests_validation.yaml",
    "chars": 3760,
    "preview": "name: ✔️ Verification of integration\n\non:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n"
  },
  {
    "path": ".github/workflows/label.yaml",
    "chars": 451,
    "preview": "name: 🏷️ Pull Request Labels\n\non:\n  pull_request:\n    types: [opened, labeled, unlabeled, synchronize]\njobs:\n  label:\n  "
  },
  {
    "path": ".github/workflows/podman_tests.yaml",
    "chars": 2684,
    "preview": "name: 🧪 Test for podman\n\non:\n  schedule:\n  - cron: \"0 0 * * *\"\n  workflow_dispatch:\n\njobs:\n  podman-tests:\n    runs-on: "
  },
  {
    "path": ".github/workflows/release.yaml",
    "chars": 3557,
    "preview": "name: 🚀 Release\n\non:\n  push:\n    tags: [\"v[0-9]+.[0-9]+.[0-9]+*\"]\n  workflow_dispatch:\n\njobs:\n  parse:\n    runs-on: ubun"
  },
  {
    "path": ".github/workflows/runc_integration_tests.yaml",
    "chars": 1419,
    "preview": "name: 🧪 Runc integration test\n\non:\n  schedule:\n  - cron: \"0 0 * * *\"\n  workflow_dispatch:\n\njobs:\n  runc-integration-test"
  },
  {
    "path": ".github/workflows/selinux.yaml",
    "chars": 1560,
    "preview": "name: 🧪 SELinux Tests\n\non:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n  workflow_disp"
  },
  {
    "path": ".github/workflows/tagpr.yaml",
    "chars": 832,
    "preview": "name: 🚀 Tagpr for GitHub Actions\non:\n  push:\n    branches:\n      - main\njobs:\n  tagpr:\n    runs-on: ubuntu-latest\n    st"
  },
  {
    "path": ".github/workflows/update_version_config.yaml",
    "chars": 1427,
    "preview": "name:  🤖 Automated Update tagpr config\n\non:\n  workflow_dispatch:\n    inputs:\n      version:\n        description: 'Versio"
  },
  {
    "path": ".gitignore",
    "chars": 207,
    "preview": "/tutorial\n.idea/\n\n**/target\n/contest-target\n/bin\n.vagrant/\n\ntags\ntags.lock\ntags.temp\n\n/youki\n/runtimetest\n/contest\n\n.vsc"
  },
  {
    "path": ".gitmodules",
    "chars": 420,
    "preview": "[submodule \"tests/oci-runtime-tests/src/github.com/opencontainers/runtime-tools\"]\n\tpath = tests/oci-runtime-tests/src/gi"
  },
  {
    "path": ".tagpr",
    "chars": 149,
    "preview": "[tagpr]\n    vPrefix = true\n    releaseBranch = main\n    versionFile = -\n    command = just version-up 0.6.1\n    release "
  },
  {
    "path": ".typos.toml",
    "chars": 663,
    "preview": "# Configuration Reference:\n#  - https://github.com/crate-ci/typos/blob/927308c726b1fba730f7aaa8bde602148b82004d/docs/ref"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 235569,
    "preview": "# Changelog\n\n## [v0.6.0](https://github.com/youki-dev/youki/compare/v0.5.7...v0.6.0) - 2026-02-25\n### 💪 Improvements\n- A"
  },
  {
    "path": "CODE-OF-CONDUCT.md",
    "chars": 76,
    "preview": "Move to youki-dev.github.io/youki/community/governance.html#code-of-conduct\n"
  },
  {
    "path": "Cargo.toml",
    "chars": 165,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\"crates/*\", \"tests/contest/*\", \"tools/*\"]\nexclude = [\"experiment/seccomp\", \"experi"
  },
  {
    "path": "Cross.toml",
    "chars": 380,
    "preview": "[build]\ndefault-target = \"x86_64-unknown-linux-gnu\"\nenv.passthrough = [\"XDG_RUNTIME_DIR\"]\n\n[target.aarch64-unknown-linux"
  },
  {
    "path": "LICENSE",
    "chars": 11344,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "MigrationGuide.md",
    "chars": 1787,
    "preview": "# Migration Guide\n\nThis contains information for migrating library versions.\n\n## v0.2.0 -> v0.3.0\n\n### libcgroups\n- Swit"
  },
  {
    "path": "README.md",
    "chars": 11048,
    "preview": "# youki: A container runtime in Rust\n\n[![Discord](https://img.shields.io/discord/849943000770412575.svg?logo=discord)](h"
  },
  {
    "path": "SECURITY.md",
    "chars": 233,
    "preview": "## Security and Disclosure Information Policy for the Youki Project\n\nThe Youki Project follows the [Security and Disclos"
  },
  {
    "path": "Vagrantfile",
    "chars": 7001,
    "preview": "# -*- mode: ruby -*-\n# vi: set ft=ruby :\n\nCONTAINERD_2_YOUKI_GO_VERSION = \"1.20.12\"\nCONTAINERD_2_YOUKI_CONTAINERD_VERSIO"
  },
  {
    "path": "crates/.gitignore",
    "chars": 5,
    "preview": "*_bin"
  },
  {
    "path": "crates/libcgroups/.gitignore",
    "chars": 27,
    "preview": "debug/\ntarget/\n**/*.rs.bk\n\n"
  },
  {
    "path": "crates/libcgroups/Cargo.toml",
    "chars": 1384,
    "preview": "[package]\nname = \"libcgroups\"\nversion = \"0.6.0\" # MARK: Version\ndescription = \"Library for cgroup\"\nlicense = \"Apache-2.0"
  },
  {
    "path": "crates/libcgroups/README.md",
    "chars": 13,
    "preview": "# libcgroups\n"
  },
  {
    "path": "crates/libcgroups/examples/bpf.rs",
    "chars": 4017,
    "preview": "use anyhow::Result;\n\n#[cfg(feature = \"cgroupsv2_devices\")]\nmod bpf {\n    use std::os::unix::io::AsRawFd;\n    use std::pa"
  },
  {
    "path": "crates/libcgroups/examples/rules.json",
    "chars": 245,
    "preview": "[\n    {\n        \"allow\": false,\n        \"access\": \"rwm\"\n    },\n    {\n        \"allow\": true,\n        \"type\": \"c\",\n       "
  },
  {
    "path": "crates/libcgroups/examples/systemd_io.rs",
    "chars": 2107,
    "preview": "use std::path::PathBuf;\nuse std::process::{Command, Stdio};\n\nuse anyhow::Result;\nuse libcgroups::common::{CgroupConfig, "
  },
  {
    "path": "crates/libcgroups/src/common.rs",
    "chars": 22611,
    "preview": "use std::fmt::{Debug, Display};\nuse std::fs::{self, File};\nuse std::io::{BufRead, BufReader, Write};\nuse std::path::{Pat"
  },
  {
    "path": "crates/libcgroups/src/lib.rs",
    "chars": 743,
    "preview": "//! Control groups provide a way of controlling groups of processes.\n//! Examples: controlling resource limits, executio"
  },
  {
    "path": "crates/libcgroups/src/stats.rs",
    "chars": 22694,
    "preview": "use std::collections::HashMap;\nuse std::fmt::Display;\nuse std::fs;\nuse std::num::ParseIntError;\nuse std::path::{Path, Pa"
  },
  {
    "path": "crates/libcgroups/src/stub/systemd/manager.rs",
    "chars": 1208,
    "preview": "use crate::common::{AnyCgroupManager, CgroupManager};\n\n#[derive(thiserror::Error, Debug)]\npub enum SystemdManagerError {"
  },
  {
    "path": "crates/libcgroups/src/stub/systemd/mod.rs",
    "chars": 17,
    "preview": "pub mod manager;\n"
  },
  {
    "path": "crates/libcgroups/src/stub/v1/manager.rs",
    "chars": 1163,
    "preview": "use crate::common::{AnyCgroupManager, CgroupManager};\n\n#[derive(thiserror::Error, Debug)]\npub enum V1ManagerError {\n    "
  },
  {
    "path": "crates/libcgroups/src/stub/v1/mod.rs",
    "chars": 17,
    "preview": "pub mod manager;\n"
  },
  {
    "path": "crates/libcgroups/src/stub/v2/manager.rs",
    "chars": 1163,
    "preview": "use crate::common::{AnyCgroupManager, CgroupManager};\n\n#[derive(thiserror::Error, Debug)]\npub enum V2ManagerError {\n    "
  },
  {
    "path": "crates/libcgroups/src/stub/v2/mod.rs",
    "chars": 17,
    "preview": "pub mod manager;\n"
  },
  {
    "path": "crates/libcgroups/src/systemd/controller.rs",
    "chars": 320,
    "preview": "use std::collections::HashMap;\n\nuse super::dbus_native::serialize::Variant;\nuse crate::common::ControllerOpt;\n\npub(super"
  },
  {
    "path": "crates/libcgroups/src/systemd/controller_type.rs",
    "chars": 1031,
    "preview": "use std::fmt::Display;\n\npub enum ControllerType {\n    Cpu,\n    CpuSet,\n    Io,\n    Memory,\n    Pids,\n}\n\nimpl Display for"
  },
  {
    "path": "crates/libcgroups/src/systemd/cpu.rs",
    "chars": 5721,
    "preview": "use std::collections::HashMap;\n\nuse oci_spec::runtime::LinuxCpu;\n\nuse super::controller::Controller;\nuse super::dbus_nat"
  },
  {
    "path": "crates/libcgroups/src/systemd/cpuset.rs",
    "chars": 7399,
    "preview": "use std::collections::HashMap;\n\nuse fixedbitset::FixedBitSet;\nuse oci_spec::runtime::LinuxCpu;\n\nuse super::controller::C"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/client.rs",
    "chars": 992,
    "preview": "use std::collections::HashMap;\nuse std::path::PathBuf;\n\nuse super::serialize::Variant;\nuse super::utils::SystemdClientEr"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/dbus.rs",
    "chars": 21017,
    "preview": "use std::collections::HashMap;\nuse std::io::{IoSlice, IoSliceMut};\nuse std::os::fd::AsRawFd;\nuse std::path::PathBuf;\nuse"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/message.rs",
    "chars": 30347,
    "preview": "use super::utils::{DbusError, Result, adjust_padding, align_counter};\n\n#[derive(Debug)]\n/// Indicates the endian of mess"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/mod.rs",
    "chars": 232,
    "preview": "// see https://dbus.freedesktop.org/doc/dbus-specification.html and\n// https://dbus.freedesktop.org/doc/api/html/structD"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/proxy.rs",
    "chars": 8810,
    "preview": "use super::dbus::DbusConnection;\nuse super::message::*;\nuse super::serialize::{DbusSerialize, Structure, Variant};\nuse s"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/serialize.rs",
    "chars": 16442,
    "preview": "use super::utils::{DbusError, Result, adjust_padding, align_counter};\n\n/// This indicates that given type can be seriali"
  },
  {
    "path": "crates/libcgroups/src/systemd/dbus_native/utils.rs",
    "chars": 4512,
    "preview": "use std::num::ParseIntError;\n\n#[derive(thiserror::Error, Debug)]\npub enum SystemdClientError {\n    #[error(\"dbus error: "
  },
  {
    "path": "crates/libcgroups/src/systemd/io.rs",
    "chars": 7471,
    "preview": "use std::collections::HashMap;\nuse std::fs;\nuse std::path::Path;\n\nuse oci_spec::runtime::{LinuxBlockIo, LinuxThrottleDev"
  },
  {
    "path": "crates/libcgroups/src/systemd/manager.rs",
    "chars": 22835,
    "preview": "use std::collections::HashMap;\nuse std::convert::Infallible;\nuse std::fmt::{Debug, Display};\nuse std::fs::{self};\nuse st"
  },
  {
    "path": "crates/libcgroups/src/systemd/memory.rs",
    "chars": 6253,
    "preview": "use std::collections::HashMap;\n\nuse oci_spec::runtime::LinuxMemory;\n\nuse super::controller::Controller;\nuse super::dbus_"
  },
  {
    "path": "crates/libcgroups/src/systemd/mod.rs",
    "chars": 570,
    "preview": "use std::fs;\n\nmod controller;\npub mod controller_type;\nmod cpu;\nmod cpuset;\nmod dbus_native;\nmod io;\npub mod manager;\nmo"
  },
  {
    "path": "crates/libcgroups/src/systemd/pids.rs",
    "chars": 3616,
    "preview": "use std::collections::HashMap;\nuse std::convert::Infallible;\n\nuse oci_spec::runtime::LinuxPids;\n\nuse super::controller::"
  },
  {
    "path": "crates/libcgroups/src/systemd/unified.rs",
    "chars": 9325,
    "preview": "use std::collections::HashMap;\nuse std::num::ParseIntError;\n\nuse super::controller::Controller;\nuse super::cpu::{self, c"
  },
  {
    "path": "crates/libcgroups/src/test.rs",
    "chars": 857,
    "preview": "#![cfg(test)]\n\nuse std::io::Write;\nuse std::path::{Path, PathBuf};\n\nuse anyhow::{Context, Result};\n\npub fn setup(cgroup_"
  },
  {
    "path": "crates/libcgroups/src/test_manager.rs",
    "chars": 1464,
    "preview": "use std::cell::RefCell;\nuse std::convert::Infallible;\n\nuse nix::unistd::Pid;\n\nuse crate::common::{CgroupManager, Control"
  },
  {
    "path": "crates/libcgroups/src/v1/blkio.rs",
    "chars": 15015,
    "preview": "use std::num::ParseIntError;\nuse std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::LinuxBlockIo;\n\nuse super::controlle"
  },
  {
    "path": "crates/libcgroups/src/v1/controller.rs",
    "chars": 836,
    "preview": "use std::fs;\nuse std::path::Path;\n\nuse nix::unistd::Pid;\n\nuse crate::common::{self, CGROUP_PROCS, ControllerOpt, WrapIoR"
  },
  {
    "path": "crates/libcgroups/src/v1/controller_type.rs",
    "chars": 1939,
    "preview": "use std::fmt::Display;\n\n#[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]\npub enum ControllerType {\n    Cpu,\n    CpuAcc"
  },
  {
    "path": "crates/libcgroups/src/v1/cpu.rs",
    "chars": 8921,
    "preview": "use std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::LinuxCpu;\n\nuse super::controller::Controller;\nuse crate::common:"
  },
  {
    "path": "crates/libcgroups/src/v1/cpuacct.rs",
    "chars": 7720,
    "preview": "use std::num::ParseIntError;\nuse std::path::{Path, PathBuf};\n\nuse super::controller::Controller;\nuse crate::common::{sel"
  },
  {
    "path": "crates/libcgroups/src/v1/cpuset.rs",
    "chars": 5005,
    "preview": "use std::fs;\nuse std::path::{Path, PathBuf, StripPrefixError};\n\nuse nix::unistd;\nuse oci_spec::runtime::LinuxCpu;\nuse un"
  },
  {
    "path": "crates/libcgroups/src/v1/devices.rs",
    "chars": 6632,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxDeviceCgroup;\n\nuse super::controller::Controller;\nuse crate::common::{"
  },
  {
    "path": "crates/libcgroups/src/v1/freezer.rs",
    "chars": 10291,
    "preview": "use std::fs::OpenOptions;\nuse std::io::Read;\nuse std::path::Path;\nuse std::{thread, time};\n\nuse super::controller::Contr"
  },
  {
    "path": "crates/libcgroups/src/v1/hugetlb.rs",
    "chars": 10151,
    "preview": "use std::collections::HashMap;\nuse std::num::ParseIntError;\nuse std::path::Path;\n\nuse oci_spec::runtime::LinuxHugepageLi"
  },
  {
    "path": "crates/libcgroups/src/v1/manager.rs",
    "chars": 11162,
    "preview": "use std::collections::HashMap;\nuse std::fs;\nuse std::path::{Path, PathBuf};\nuse std::time::Duration;\n\nuse nix::unistd::P"
  },
  {
    "path": "crates/libcgroups/src/v1/memory.rs",
    "chars": 27937,
    "preview": "use std::collections::HashMap;\nuse std::fmt::Display;\nuse std::fs::OpenOptions;\nuse std::io::Write;\nuse std::io::prelude"
  },
  {
    "path": "crates/libcgroups/src/v1/mod.rs",
    "chars": 307,
    "preview": "mod blkio;\nmod controller;\nmod controller_type;\nmod cpu;\nmod cpuacct;\nmod cpuset;\nmod devices;\nmod freezer;\nmod hugetlb;"
  },
  {
    "path": "crates/libcgroups/src/v1/network_classifier.rs",
    "chars": 1824,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxNetwork;\n\nuse super::controller::Controller;\nuse crate::common::{self,"
  },
  {
    "path": "crates/libcgroups/src/v1/network_priority.rs",
    "chars": 2396,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxNetwork;\n\nuse super::controller::Controller;\nuse crate::common::{self,"
  },
  {
    "path": "crates/libcgroups/src/v1/perf_event.rs",
    "chars": 1015,
    "preview": "use std::path::Path;\n\nuse super::controller::Controller;\nuse crate::common::{ControllerOpt, WrappedIoError};\n\npub struct"
  },
  {
    "path": "crates/libcgroups/src/v1/pids.rs",
    "chars": 3398,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxPids;\n\nuse super::controller::Controller;\nuse crate::common::{self, Co"
  },
  {
    "path": "crates/libcgroups/src/v1/util.rs",
    "chars": 3863,
    "preview": "use std::collections::HashMap;\nuse std::io::{BufRead, BufReader};\nuse std::path::PathBuf;\n\nuse pathrs::flags::OpenFlags;"
  },
  {
    "path": "crates/libcgroups/src/v2/controller.rs",
    "chars": 199,
    "preview": "use std::path::Path;\n\nuse crate::common::ControllerOpt;\n\npub(super) trait Controller {\n    type Error;\n\n    fn apply(con"
  },
  {
    "path": "crates/libcgroups/src/v2/controller_type.rs",
    "chars": 1391,
    "preview": "use std::fmt::Display;\n\n#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]\npub enum ControllerType {\n    Cpu,\n    CpuSet"
  },
  {
    "path": "crates/libcgroups/src/v2/cpu.rs",
    "chars": 13697,
    "preview": "use std::borrow::Cow;\nuse std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::LinuxCpu;\n\nuse super::controller::Controll"
  },
  {
    "path": "crates/libcgroups/src/v2/cpuset.rs",
    "chars": 2121,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxCpu;\n\nuse super::controller::Controller;\nuse crate::common::{self, Con"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/bpf.rs",
    "chars": 12325,
    "preview": "#[derive(Clone)]\npub struct ProgramInfo {\n    pub id: u32,\n    pub fd: i32,\n}\n\n#[derive(thiserror::Error, Debug)]\npub en"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/controller.rs",
    "chars": 6261,
    "preview": "use std::os::unix::io::AsRawFd;\nuse std::path::Path;\n\n#[cfg(test)]\nuse bpf::mock_prog as bpf_prog;\n#[cfg(not(test))]\nuse"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/emulator.rs",
    "chars": 3512,
    "preview": "use oci_spec::runtime::{LinuxDeviceCgroup, LinuxDeviceType};\n\n// For cgroup v1 compatibility, runc implements a device e"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/mocks.rs",
    "chars": 2025,
    "preview": "// Here we duplicate the signatures of external functions and apply\n// the mockall::automock macro to generate mock modu"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/mod.rs",
    "chars": 164,
    "preview": "pub mod bpf;\npub mod controller;\npub mod emulator;\npub mod program;\n\n#[cfg(test)]\n#[allow(clippy::too_many_arguments)]\np"
  },
  {
    "path": "crates/libcgroups/src/v2/devices/program.rs",
    "chars": 14577,
    "preview": "use oci_spec::runtime::*;\nuse rbpf::disassembler::disassemble;\nuse rbpf::insn_builder::{Arch as RbpfArch, *};\n\npub struc"
  },
  {
    "path": "crates/libcgroups/src/v2/freezer.rs",
    "chars": 7133,
    "preview": "use std::fs::OpenOptions;\nuse std::io::{BufRead, BufReader, Read, Seek, Write};\nuse std::path::Path;\nuse std::str::{self"
  },
  {
    "path": "crates/libcgroups/src/v2/hugetlb.rs",
    "chars": 9284,
    "preview": "use std::collections::HashMap;\nuse std::num::ParseIntError;\nuse std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::Linu"
  },
  {
    "path": "crates/libcgroups/src/v2/io.rs",
    "chars": 14146,
    "preview": "use std::num::ParseIntError;\nuse std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::LinuxBlockIo;\n\nuse super::controlle"
  },
  {
    "path": "crates/libcgroups/src/v2/manager.rs",
    "chars": 8830,
    "preview": "use std::fs::{self};\nuse std::os::unix::fs::PermissionsExt;\nuse std::path::Component::RootDir;\nuse std::path::{Path, Pat"
  },
  {
    "path": "crates/libcgroups/src/v2/memory.rs",
    "chars": 14999,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxMemory;\n\nuse super::controller::Controller;\nuse crate::common::{self, "
  },
  {
    "path": "crates/libcgroups/src/v2/mod.rs",
    "chars": 217,
    "preview": "mod controller;\npub mod controller_type;\nmod cpu;\nmod cpuset;\n#[cfg(feature = \"cgroupsv2_devices\")]\npub mod devices;\nmod"
  },
  {
    "path": "crates/libcgroups/src/v2/pids.rs",
    "chars": 2338,
    "preview": "use std::path::Path;\n\nuse oci_spec::runtime::LinuxPids;\n\nuse super::controller::Controller;\nuse crate::common::{self, Co"
  },
  {
    "path": "crates/libcgroups/src/v2/unified.rs",
    "chars": 5112,
    "preview": "use std::collections::HashMap;\nuse std::path::Path;\n\nuse super::controller_type::ControllerType;\nuse crate::common::{sel"
  },
  {
    "path": "crates/libcgroups/src/v2/util.rs",
    "chars": 2753,
    "preview": "use std::io::{BufRead, BufReader};\nuse std::path::{Path, PathBuf};\n\nuse pathrs::flags::OpenFlags;\nuse pathrs::procfs::{P"
  },
  {
    "path": "crates/libcontainer/Cargo.toml",
    "chars": 1777,
    "preview": "[package]\nname = \"libcontainer\"\nversion = \"0.6.0\" # MARK: Version\ndescription = \"Library for container control\"\nlicense "
  },
  {
    "path": "crates/libcontainer/README.md",
    "chars": 941,
    "preview": "# libcontainer\n\n### Building with musl\n\nIn order to build with musl you must first remove the libseccomp dependency as i"
  },
  {
    "path": "crates/libcontainer/src/apparmor.rs",
    "chars": 1777,
    "preview": "use std::fs;\nuse std::io::Write;\nuse std::path::{Path, PathBuf};\n\nuse pathrs::flags::OpenFlags;\nuse pathrs::procfs::{Pro"
  },
  {
    "path": "crates/libcontainer/src/capabilities.rs",
    "chars": 26435,
    "preview": "//! Handles Management of Capabilities\nuse caps::{Capability as CapsCapability, *};\nuse oci_spec::runtime::{Capabilities"
  },
  {
    "path": "crates/libcontainer/src/channel.rs",
    "chars": 6615,
    "preview": "use std::io::{IoSlice, IoSliceMut};\nuse std::marker::PhantomData;\nuse std::os::fd::AsRawFd;\nuse std::os::unix::prelude::"
  },
  {
    "path": "crates/libcontainer/src/config.rs",
    "chars": 3796,
    "preview": "use std::fs;\nuse std::io::{BufReader, BufWriter, Write};\nuse std::path::{Path, PathBuf};\n\nuse oci_spec::runtime::{Hooks,"
  },
  {
    "path": "crates/libcontainer/src/container/builder.rs",
    "chars": 15901,
    "preview": "use std::os::fd::OwnedFd;\nuse std::path::PathBuf;\n\nuse super::init_builder::InitContainerBuilder;\nuse super::tenant_buil"
  },
  {
    "path": "crates/libcontainer/src/container/builder_impl.rs",
    "chars": 9928,
    "preview": "use std::fs;\nuse std::io::Write;\nuse std::os::fd::{AsRawFd, OwnedFd};\nuse std::path::PathBuf;\nuse std::rc::Rc;\n\nuse libc"
  },
  {
    "path": "crates/libcontainer/src/container/container.rs",
    "chars": 11124,
    "preview": "use std::collections::HashMap;\nuse std::ffi::OsString;\nuse std::fs;\nuse std::path::{Path, PathBuf};\n\nuse chrono::{DateTi"
  },
  {
    "path": "crates/libcontainer/src/container/container_checkpoint.rs",
    "chars": 7992,
    "preview": "use std::fs::{DirBuilder, File, read_link};\nuse std::io::{ErrorKind, Write};\nuse std::os::unix::fs::DirBuilderExt;\nuse s"
  },
  {
    "path": "crates/libcontainer/src/container/container_criu.rs",
    "chars": 1782,
    "preview": "//! Common CRIU utilities for checkpoint and restore operations.\n//!\n//! This module provides shared functionality betwe"
  },
  {
    "path": "crates/libcontainer/src/container/container_delete.rs",
    "chars": 5358,
    "preview": "use std::fs;\n\nuse libcgroups::common::CgroupManager;\nuse libcgroups::{self};\nuse nix::sys::signal;\n\nuse super::{Containe"
  },
  {
    "path": "crates/libcontainer/src/container/container_events.rs",
    "chars": 2105,
    "preview": "use std::thread;\nuse std::time::Duration;\n\nuse libcgroups::common::CgroupManager;\n\nuse super::{Container, ContainerStatu"
  },
  {
    "path": "crates/libcontainer/src/container/container_kill.rs",
    "chars": 5052,
    "preview": "use libcgroups::common::{CgroupManager, get_cgroup_setup};\nuse nix::sys::signal::{self};\n\nuse super::{Container, Contain"
  },
  {
    "path": "crates/libcontainer/src/container/container_pause.rs",
    "chars": 1540,
    "preview": "use libcgroups::common::{CgroupManager, FreezerState};\n\nuse super::{Container, ContainerStatus};\nuse crate::error::Libco"
  },
  {
    "path": "crates/libcontainer/src/container/container_resume.rs",
    "chars": 1691,
    "preview": "use libcgroups::common::{CgroupManager, FreezerState};\n\nuse super::{Container, ContainerStatus};\nuse crate::error::Libco"
  },
  {
    "path": "crates/libcontainer/src/container/container_start.rs",
    "chars": 2234,
    "preview": "use super::{Container, ContainerStatus};\nuse crate::config::YoukiConfig;\nuse crate::error::LibcontainerError;\nuse crate:"
  },
  {
    "path": "crates/libcontainer/src/container/init_builder.rs",
    "chars": 8107,
    "preview": "use std::fs;\nuse std::path::{Path, PathBuf};\nuse std::rc::Rc;\n\nuse oci_spec::runtime::Spec;\nuse user_ns::UserNamespaceCo"
  },
  {
    "path": "crates/libcontainer/src/container/mod.rs",
    "chars": 981,
    "preview": "//! Container management\n/// This crate is responsible for the creation of containers. It provides a builder that can\n//"
  },
  {
    "path": "crates/libcontainer/src/container/state.rs",
    "chars": 11768,
    "preview": "//! Information about status and state of the container\nuse std::collections::HashMap;\nuse std::fmt::Display;\nuse std::f"
  },
  {
    "path": "crates/libcontainer/src/container/tenant_builder.rs",
    "chars": 31216,
    "preview": "use std::collections::HashMap;\nuse std::convert::TryFrom;\nuse std::ffi::{OsStr, OsString};\nuse std::fs;\nuse std::io::Buf"
  },
  {
    "path": "crates/libcontainer/src/error.rs",
    "chars": 6170,
    "preview": "use crate::container::ContainerStatus;\n\n#[derive(Debug, thiserror::Error)]\npub enum MissingSpecError {\n    #[error(\"miss"
  },
  {
    "path": "crates/libcontainer/src/hooks.rs",
    "chars": 12613,
    "preview": "use std::collections::HashMap;\nuse std::io::{ErrorKind, Write};\nuse std::os::unix::prelude::CommandExt;\nuse std::path::P"
  },
  {
    "path": "crates/libcontainer/src/lib.rs",
    "chars": 664,
    "preview": "pub mod apparmor;\npub mod capabilities;\npub mod channel;\npub mod config;\npub mod container;\npub mod error;\npub mod hooks"
  },
  {
    "path": "crates/libcontainer/src/namespaces.rs",
    "chars": 7135,
    "preview": "//! Namespaces provide isolation of resources for processes at a kernel level.\n//! The namespaces are: Mount (filesystem"
  },
  {
    "path": "crates/libcontainer/src/network/address.rs",
    "chars": 20490,
    "preview": "use std::net::{IpAddr, Ipv4Addr};\n\nuse netlink_packet_core::{\n    NLM_F_ACK, NLM_F_CREATE, NLM_F_DUMP, NLM_F_EXCL, NLM_F"
  },
  {
    "path": "crates/libcontainer/src/network/cidr.rs",
    "chars": 4839,
    "preview": "use std::net::IpAddr;\n\nuse netlink_packet_route::address::{AddressAttribute, AddressMessage};\nuse serde::{Deserialize, S"
  },
  {
    "path": "crates/libcontainer/src/network/client.rs",
    "chars": 4253,
    "preview": "use netlink_packet_core::NetlinkMessage;\nuse netlink_packet_route::RouteNetlinkMessage;\nuse netlink_sys::Socket;\nuse net"
  },
  {
    "path": "crates/libcontainer/src/network/fake.rs",
    "chars": 5396,
    "preview": "use std::collections::VecDeque;\n\nuse netlink_packet_core::{NetlinkMessage, NetlinkPayload};\nuse netlink_packet_route::Ro"
  },
  {
    "path": "crates/libcontainer/src/network/link.rs",
    "chars": 17391,
    "preview": "use std::os::fd::RawFd;\n\nuse netlink_packet_core::{\n    NLM_F_ACK, NLM_F_CREATE, NLM_F_EXCL, NLM_F_REQUEST, NetlinkMessa"
  },
  {
    "path": "crates/libcontainer/src/network/mod.rs",
    "chars": 856,
    "preview": "pub mod address;\npub mod cidr;\nmod client;\nmod fake;\npub mod link;\npub mod network_device;\nmod traits;\npub mod wrapper;\n"
  },
  {
    "path": "crates/libcontainer/src/network/network_device.rs",
    "chars": 7108,
    "preview": "use std::os::fd::RawFd;\n\nuse netlink_packet_route::address::{AddressHeaderFlags, AddressScope};\nuse oci_spec::runtime::L"
  },
  {
    "path": "crates/libcontainer/src/network/traits.rs",
    "chars": 3205,
    "preview": "use netlink_packet_core::{NetlinkMessage, NetlinkPayload};\nuse netlink_packet_route::RouteNetlinkMessage;\n\nuse super::{N"
  },
  {
    "path": "crates/libcontainer/src/network/wrapper.rs",
    "chars": 3503,
    "preview": "use netlink_packet_core::NetlinkMessage;\nuse netlink_packet_route::RouteNetlinkMessage;\n\nuse super::client::NetlinkClien"
  },
  {
    "path": "crates/libcontainer/src/notify_socket.rs",
    "chars": 7018,
    "preview": "use std::env;\nuse std::io::prelude::*;\nuse std::os::fd::FromRawFd;\nuse std::os::unix::io::AsRawFd;\nuse std::os::unix::ne"
  },
  {
    "path": "crates/libcontainer/src/process/args.rs",
    "chars": 2123,
    "preview": "use std::os::unix::prelude::RawFd;\nuse std::path::PathBuf;\nuse std::rc::Rc;\n\nuse libcgroups::common::CgroupConfig;\nuse o"
  },
  {
    "path": "crates/libcontainer/src/process/channel.rs",
    "chars": 19983,
    "preview": "use std::collections::HashMap;\nuse std::os::unix::prelude::{AsRawFd, RawFd};\n\nuse nix::unistd::Pid;\n\nuse crate::channel:"
  },
  {
    "path": "crates/libcontainer/src/process/container_intermediate_process.rs",
    "chars": 13105,
    "preview": "use std::os::fd::FromRawFd;\n\nuse libcgroups::common::CgroupManager;\nuse nix::unistd::{Gid, Pid, Uid, close, getpid, writ"
  },
  {
    "path": "crates/libcontainer/src/process/container_main_process.rs",
    "chars": 19997,
    "preview": "use std::collections::HashMap;\nuse std::fs;\nuse std::fs::File;\nuse std::os::fd::AsRawFd;\nuse std::path::PathBuf;\n\nuse ni"
  },
  {
    "path": "crates/libcontainer/src/process/cpu_affinity.rs",
    "chars": 4942,
    "preview": "use nix::sched::{CpuSet, sched_getaffinity, sched_setaffinity};\nuse nix::unistd::Pid;\nuse tracing::{Level, enabled};\n\n#["
  },
  {
    "path": "crates/libcontainer/src/process/fork.rs",
    "chars": 16471,
    "preview": "use std::ffi::c_int;\nuse std::num::NonZeroUsize;\n\nuse libc::SIGCHLD;\nuse nix::sys::{mman, resource};\nuse nix::unistd::Pi"
  },
  {
    "path": "crates/libcontainer/src/process/init/context.rs",
    "chars": 1792,
    "preview": "use std::collections::HashMap;\nuse std::path::Path;\n\nuse oci_spec::runtime;\n\nuse super::Result;\nuse crate::container::Co"
  },
  {
    "path": "crates/libcontainer/src/process/init/error.rs",
    "chars": 3070,
    "preview": "use crate::namespaces::NamespaceError;\nuse crate::process::channel;\nuse crate::process::memory_policy::MemoryPolicyError"
  },
  {
    "path": "crates/libcontainer/src/process/init/mod.rs",
    "chars": 154,
    "preview": "mod context;\npub mod error;\npub mod process;\n\npub use process::container_init_process;\n\ntype Result<T> = std::result::Re"
  },
  {
    "path": "crates/libcontainer/src/process/init/process.rs",
    "chars": 54217,
    "preview": "use std::collections::HashMap;\nuse std::io::{Read, Write};\nuse std::os::unix::io::AsRawFd;\nuse std::path::{Path, PathBuf"
  },
  {
    "path": "crates/libcontainer/src/process/intel_rdt.rs",
    "chars": 22777,
    "preview": "use std::collections::HashMap;\nuse std::fs::{self, OpenOptions};\nuse std::io::{BufRead, BufReader, Write};\nuse std::path"
  },
  {
    "path": "crates/libcontainer/src/process/memory_policy.rs",
    "chars": 19379,
    "preview": "use std::fmt;\n\nuse oci_spec::runtime::{MemoryPolicyFlagType, MemoryPolicyModeType};\n\nuse crate::syscall::{Syscall, Sysca"
  },
  {
    "path": "crates/libcontainer/src/process/message.rs",
    "chars": 1553,
    "preview": "use core::fmt;\nuse std::collections::HashMap;\n\nuse serde::{Deserialize, Serialize};\n\nuse crate::network::cidr::CidrAddre"
  },
  {
    "path": "crates/libcontainer/src/process/mod.rs",
    "chars": 366,
    "preview": "//! Provides a thin wrapper around fork syscall,\n//! with enums and functions specific to youki implemented\n\npub mod arg"
  },
  {
    "path": "crates/libcontainer/src/process/seccomp_listener.rs",
    "chars": 6864,
    "preview": "use std::io::IoSlice;\nuse std::os::fd::AsRawFd;\nuse std::path::Path;\n\nuse nix::sys::socket::{self, UnixAddr};\nuse nix::u"
  },
  {
    "path": "crates/libcontainer/src/rootfs/device.rs",
    "chars": 11273,
    "preview": "use std::os::unix::io::{AsRawFd, FromRawFd, OwnedFd};\nuse std::path::{Path, PathBuf};\n\nuse libc;\nuse nix::fcntl::{OFlag,"
  },
  {
    "path": "crates/libcontainer/src/rootfs/mod.rs",
    "chars": 926,
    "preview": "//! During kernel initialization, a minimal replica of the ramfs filesystem is\n//! loaded, called rootfs.  Most systems "
  },
  {
    "path": "crates/libcontainer/src/rootfs/mount.rs",
    "chars": 60078,
    "preview": "use std::fs::{Permissions, canonicalize};\nuse std::io::{BufRead, BufReader, ErrorKind};\nuse std::os::fd::{AsFd, OwnedFd}"
  },
  {
    "path": "crates/libcontainer/src/rootfs/rootfs.rs",
    "chars": 4437,
    "preview": "use std::collections::HashSet;\nuse std::path::Path;\n\nuse nix::mount::MsFlags;\nuse oci_spec::runtime::{Linux, Spec};\n\nuse"
  },
  {
    "path": "crates/libcontainer/src/rootfs/symlink.rs",
    "chars": 7729,
    "preview": "use std::fs::remove_file;\nuse std::path::Path;\n\nuse crate::syscall::Syscall;\nuse crate::syscall::syscall::create_syscall"
  },
  {
    "path": "crates/libcontainer/src/rootfs/utils.rs",
    "chars": 18209,
    "preview": "use std::path::PathBuf;\nuse std::str::FromStr;\n\nuse nix::mount::MsFlags;\nuse nix::sys::stat::SFlag;\nuse oci_spec::runtim"
  },
  {
    "path": "crates/libcontainer/src/seccomp/fixture/config.json",
    "chars": 30978,
    "preview": "{\n    \"ociVersion\": \"1.0.1-dev\",\n    \"process\": {\n        \"terminal\": false,\n        \"user\": {\n            \"uid\": 0,\n   "
  },
  {
    "path": "crates/libcontainer/src/seccomp/mod.rs",
    "chars": 16139,
    "preview": "use std::num::TryFromIntError;\nuse std::os::unix::io;\n\nuse libseccomp::{\n    ScmpAction, ScmpArch, ScmpArgCompare, ScmpC"
  },
  {
    "path": "crates/libcontainer/src/signal.rs",
    "chars": 5168,
    "preview": "//! Returns *nix signal enum value from passed string\n\nuse std::convert::TryFrom;\n\nuse nix::sys::signal::Signal as NixSi"
  },
  {
    "path": "crates/libcontainer/src/syscall/linux.rs",
    "chars": 37484,
    "preview": "//! Implements Command trait for Linux systems\nuse std::any::Any;\nuse std::ffi::{CStr, CString, OsStr};\nuse std::os::fd:"
  },
  {
    "path": "crates/libcontainer/src/syscall/mod.rs",
    "chars": 756,
    "preview": "//! Contains a wrapper of syscalls for unit tests\n//! This provides a uniform interface for rest of Youki\n//! to call sy"
  },
  {
    "path": "crates/libcontainer/src/syscall/syscall.rs",
    "chars": 4037,
    "preview": "//! An interface trait so that rest of Youki can call\n//! necessary functions without having to worry about their\n//! im"
  },
  {
    "path": "crates/libcontainer/src/syscall/test.rs",
    "chars": 14616,
    "preview": "use std::any::Any;\nuse std::cell::{Ref, RefCell, RefMut};\nuse std::collections::HashMap;\nuse std::ffi::{OsStr, OsString}"
  },
  {
    "path": "crates/libcontainer/src/test_utils.rs",
    "chars": 4084,
    "preview": "use nix::sys::wait;\nuse serde::{Deserialize, Serialize};\n\n// Normally, error types are not implemented as serialize/dese"
  },
  {
    "path": "crates/libcontainer/src/tty.rs",
    "chars": 19092,
    "preview": "//! tty (teletype) for user-system interaction\n//!\n//! This module handles console/TTY setup for containers.\n//!\n//! Con"
  },
  {
    "path": "crates/libcontainer/src/user_ns.rs",
    "chars": 22451,
    "preview": "use std::path::{Path, PathBuf};\nuse std::process::Command;\nuse std::{env, fs};\n\nuse nix::unistd::Pid;\nuse oci_spec::runt"
  },
  {
    "path": "crates/libcontainer/src/utils.rs",
    "chars": 21350,
    "preview": "//! Utility functionality\n\nuse std::collections::HashMap;\nuse std::fs::{self, DirBuilder, File};\nuse std::os::fd::{AsRaw"
  },
  {
    "path": "crates/libcontainer/src/workload/default.rs",
    "chars": 8084,
    "preview": "use std::ffi::CString;\nuse std::path::{Path, PathBuf};\n\nuse nix::unistd;\nuse oci_spec::runtime::Spec;\n\nuse super::{Execu"
  },
  {
    "path": "crates/libcontainer/src/workload/mod.rs",
    "chars": 4161,
    "preview": "use std::collections::HashMap;\nuse std::env;\n\nuse oci_spec::runtime::Spec;\n\npub mod default;\n\npub static EMPTY: Vec<Stri"
  },
  {
    "path": "crates/libcontainer/tests/as_sibling.rs",
    "chars": 2940,
    "preview": "use std::collections::HashMap;\nuse std::fs::create_dir;\nuse std::hash::{DefaultHasher, Hash, Hasher};\nuse std::path::Pat"
  },
  {
    "path": "crates/liboci-cli/Cargo.toml",
    "chars": 513,
    "preview": "[package]\nname = \"liboci-cli\"\nversion = \"0.6.0\" # MARK: Version\ndescription = \"Parse command line arguments for OCI cont"
  },
  {
    "path": "crates/liboci-cli/README.md",
    "chars": 1534,
    "preview": "# liboci-cli\n\nThis is a crate to parse command line arguments for OCI container\nruntimes as specified in the [OCI Runtim"
  },
  {
    "path": "crates/liboci-cli/src/checkpoint.rs",
    "chars": 2116,
    "preview": "use std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Checkpoint a running container\n/// Reference: https://github.com/opencon"
  },
  {
    "path": "crates/liboci-cli/src/create.rs",
    "chars": 1296,
    "preview": "//! Handles the creation of a new container\nuse std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Create a container\n/// Refer"
  },
  {
    "path": "crates/liboci-cli/src/delete.rs",
    "chars": 363,
    "preview": "use clap::Parser;\n\n/// Release any resources held by the container\n#[derive(Parser, Debug)]\npub struct Delete {\n    #[cl"
  },
  {
    "path": "crates/liboci-cli/src/events.rs",
    "chars": 490,
    "preview": "use clap::Parser;\n\n/// Show resource statistics for the container\n#[derive(Parser, Debug)]\npub struct Events {\n    /// S"
  },
  {
    "path": "crates/liboci-cli/src/exec.rs",
    "chars": 3226,
    "preview": "use std::error::Error;\nuse std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Execute a process within an existing container\n//"
  },
  {
    "path": "crates/liboci-cli/src/features.rs",
    "chars": 317,
    "preview": "use clap::Parser;\n\n/// Return the features list for a container\n/// This subcommand was introduced in runc by\n/// https:"
  },
  {
    "path": "crates/liboci-cli/src/info.rs",
    "chars": 101,
    "preview": "use clap::Parser;\n\n/// Show information about the system\n#[derive(Parser, Debug)]\npub struct Info {}\n"
  },
  {
    "path": "crates/liboci-cli/src/kill.rs",
    "chars": 302,
    "preview": "use clap::Parser;\n\n/// Send the specified signal to the container\n#[derive(Parser, Debug)]\npub struct Kill {\n    #[clap("
  },
  {
    "path": "crates/liboci-cli/src/lib.rs",
    "chars": 2527,
    "preview": "use std::fmt::Debug;\nuse std::path::PathBuf;\n\nuse clap::Parser;\n\n// Subcommands that are specified in https://github.com"
  },
  {
    "path": "crates/liboci-cli/src/list.rs",
    "chars": 287,
    "preview": "use clap::Parser;\n\n/// List created containers\n#[derive(Parser, Debug)]\npub struct List {\n    /// Specify the format (de"
  },
  {
    "path": "crates/liboci-cli/src/pause.rs",
    "chars": 235,
    "preview": "use clap::Parser;\n\n/// Suspend the processes within the container\n#[derive(Parser, Debug)]\npub struct Pause {\n    #[clap"
  },
  {
    "path": "crates/liboci-cli/src/ps.rs",
    "chars": 503,
    "preview": "use clap::{self, Parser};\n\n/// Display the processes inside the container\n#[derive(Parser, Debug)]\npub struct Ps {\n    /"
  },
  {
    "path": "crates/liboci-cli/src/resume.rs",
    "chars": 235,
    "preview": "use clap::Parser;\n\n/// Resume the processes within the container\n#[derive(Parser, Debug)]\npub struct Resume {\n    #[clap"
  },
  {
    "path": "crates/liboci-cli/src/run.rs",
    "chars": 1563,
    "preview": "use std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Create a container and immediately start it\n#[derive(Parser, Debug)]\npub"
  },
  {
    "path": "crates/liboci-cli/src/spec.rs",
    "chars": 337,
    "preview": "use std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Command generates a config.json\n#[derive(Parser, Debug)]\npub struct Spec"
  },
  {
    "path": "crates/liboci-cli/src/start.rs",
    "chars": 229,
    "preview": "use clap::Parser;\n\n/// Start a previously created container\n#[derive(Parser, Debug)]\npub struct Start {\n    #[clap(value"
  },
  {
    "path": "crates/liboci-cli/src/state.rs",
    "chars": 217,
    "preview": "use clap::Parser;\n\n/// Show the container state\n#[derive(Parser, Debug)]\npub struct State {\n    #[clap(value_parser = cl"
  },
  {
    "path": "crates/liboci-cli/src/update.rs",
    "chars": 2162,
    "preview": "use std::path::PathBuf;\n\nuse clap::Parser;\n\n/// Update running container resource constraints\n#[derive(Parser, Debug)]\np"
  }
]

// ... and 244 more files (download for full content)