[INFO] fetching crate aya-ebpf 0.1.0... [INFO] checking aya-ebpf-0.1.0 against try#ccf408f4326a858c00dd845a64a86b16f360a801 for pr-129466-2 [INFO] extracting crate aya-ebpf 0.1.0 into /workspace/builds/worker-7-tc2/source [INFO] validating manifest of crates.io crate aya-ebpf 0.1.0 on toolchain ccf408f4326a858c00dd845a64a86b16f360a801 [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+ccf408f4326a858c00dd845a64a86b16f360a801" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking crates.io crate aya-ebpf 0.1.0 [INFO] finished tweaking crates.io crate aya-ebpf 0.1.0 [INFO] tweaked toml for crates.io crate aya-ebpf 0.1.0 written to /workspace/builds/worker-7-tc2/source/Cargo.toml [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+ccf408f4326a858c00dd845a64a86b16f360a801" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] [stderr] Updating crates.io index [INFO] [stderr] Locking 12 packages to latest compatible versions [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+ccf408f4326a858c00dd845a64a86b16f360a801" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:ceb6ea022f8a89cebbe621bb4987e73a935bd40dfbb726f832cfff4742a5b95a" "/opt/rustwide/cargo-home/bin/cargo" "+ccf408f4326a858c00dd845a64a86b16f360a801" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] ec9be3cf7cda07cf06b513decd7a1a83df42cc19447d1f9587173e62caab18c1 [INFO] running `Command { std: "docker" "start" "-a" "ec9be3cf7cda07cf06b513decd7a1a83df42cc19447d1f9587173e62caab18c1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "ec9be3cf7cda07cf06b513decd7a1a83df42cc19447d1f9587173e62caab18c1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "ec9be3cf7cda07cf06b513decd7a1a83df42cc19447d1f9587173e62caab18c1", kill_on_drop: false }` [INFO] [stdout] ec9be3cf7cda07cf06b513decd7a1a83df42cc19447d1f9587173e62caab18c1 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:ceb6ea022f8a89cebbe621bb4987e73a935bd40dfbb726f832cfff4742a5b95a" "/opt/rustwide/cargo-home/bin/cargo" "+ccf408f4326a858c00dd845a64a86b16f360a801" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] b77eea5c63f7b113f25f8186abdbd30785f4f1f9388db2e4f33ce9b0a4bb72af [INFO] running `Command { std: "docker" "start" "-a" "b77eea5c63f7b113f25f8186abdbd30785f4f1f9388db2e4f33ce9b0a4bb72af", kill_on_drop: false }` [INFO] [stderr] Copying to /tmp/fixit [INFO] [stderr] Running `cargo fix --edition` [INFO] [stderr] Migrating Cargo.toml from 2021 edition to 2024 [INFO] [stderr] Fixed Cargo.toml (1 fix) [INFO] [stderr] Compiling aya-ebpf-cty v0.2.1 [INFO] [stderr] Compiling aya-ebpf-bindings v0.1.0 [INFO] [stderr] Compiling proc-macro-error-attr v1.0.4 [INFO] [stderr] Compiling proc-macro-error v1.0.4 [INFO] [stderr] Compiling aya-ebpf v0.1.0 (/tmp/fixit) [INFO] [stderr] Compiling syn v2.0.77 [INFO] [stderr] Migrating build.rs from 2021 edition to 2024 [INFO] [stderr] Compiling aya-ebpf-macros v0.1.0 [INFO] [stderr] Migrating src/lib.rs from 2021 edition to 2024 [INFO] [stderr] warning: failed to automatically apply fixes suggested by rustc to crate `aya_ebpf` [INFO] [stderr] [INFO] [stderr] after fixes were automatically applied the compiler reported errors within these files: [INFO] [stderr] [INFO] [stderr] * src/args.rs [INFO] [stderr] * src/helpers.rs [INFO] [stderr] * src/lib.rs [INFO] [stderr] * src/maps/program_array.rs [INFO] [stderr] * src/programs/probe.rs [INFO] [stderr] [INFO] [stderr] This likely indicates a bug in either rustc or cargo itself, [INFO] [stderr] and we would appreciate a bug report! You're likely to see [INFO] [stderr] a number of compiler warnings after this message which cargo [INFO] [stderr] attempted to fix but failed. If you could open an issue at [INFO] [stderr] https://github.com/rust-lang/rust/issues [INFO] [stderr] quoting the full output of this command we'd be very appreciative! [INFO] [stderr] Note that you may be able to make some more progress in the near-term [INFO] [stderr] fixing code with the `--broken-code` flag [INFO] [stderr] [INFO] [stderr] The following errors were reported: [INFO] [stderr] error[E0658]: fragment specifier `expr_2021` is unstable [INFO] [stderr] --> src/helpers.rs:721:27 [INFO] [stderr] | [INFO] [stderr] 721 | ($fmt:literal $(,)? $($arg:expr_2021),* $(,)?) => {{ [INFO] [stderr] | ^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: see issue #123742 for more information [INFO] [stderr] = help: add `#![feature(expr_fragment_specifier_2024)]` to the crate attributes to enable [INFO] [stderr] = note: this compiler was built on 2024-09-17; consider upgrading it if it is out of date [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/lib.rs:16:13 [INFO] [stderr] | [INFO] [stderr] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:2:15 [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:2:44 [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:4:7 [INFO] [stderr] | [INFO] [stderr] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:6:7 [INFO] [stderr] | [INFO] [stderr] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:101:7 [INFO] [stderr] | [INFO] [stderr] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:120:7 [INFO] [stderr] | [INFO] [stderr] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 120 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:135:7 [INFO] [stderr] | [INFO] [stderr] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:150:7 [INFO] [stderr] | [INFO] [stderr] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:171:7 [INFO] [stderr] | [INFO] [stderr] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:190:7 [INFO] [stderr] | [INFO] [stderr] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 190 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:205:7 [INFO] [stderr] | [INFO] [stderr] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:220:7 [INFO] [stderr] | [INFO] [stderr] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/maps/program_array.rs:83:15 [INFO] [stderr] | [INFO] [stderr] 83 | #[cfg(not(unstable))] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/maps/program_array.rs:106:11 [INFO] [stderr] | [INFO] [stderr] 106 | #[cfg(unstable)] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:3:15 [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:3:44 [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:5:7 [INFO] [stderr] | [INFO] [stderr] 5 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 5 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:7:7 [INFO] [stderr] | [INFO] [stderr] 7 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 7 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] error: aborting due to 1 previous error; 59 warnings emitted [INFO] [stderr] [INFO] [stderr] For more information about this error, try `rustc --explain E0658`. [INFO] [stderr] Original diagnostics will follow. [INFO] [stderr] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:12:39 [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as gen; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] = note: `--force-warn keyword-idents-2024` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:14:9 [INFO] [stdout] | [INFO] [stdout] 14 | pub use gen::*; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:621:24 [INFO] [stdout] | [INFO] [stdout] 621 | let ret = unsafe { gen::bpf_get_current_comm(&mut comm as *mut _ as *mut c_void, 16u32) }; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:654:14 [INFO] [stdout] | [INFO] [stdout] 654 | unsafe { gen::bpf_get_current_pid_tgid() } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:677:14 [INFO] [stdout] | [INFO] [stdout] 677 | unsafe { gen::bpf_get_current_uid_gid() } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/lib.rs:16:13 [INFO] [stdout] | [INFO] [stdout] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:64:3 [INFO] [stdout] | [INFO] [stdout] 64 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] = note: `--force-warn unsafe-attr-outside-unsafe` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 64 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:73:3 [INFO] [stdout] | [INFO] [stdout] 73 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 73 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:15 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:44 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:4:7 [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:6:7 [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:101:7 [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:120:7 [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:135:7 [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:150:7 [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:171:7 [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:190:7 [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:205:7 [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:220:7 [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/helpers.rs:721:32 [INFO] [stdout] | [INFO] [stdout] 721 | ($fmt:literal $(,)? $($arg:expr),* $(,)?) => {{ [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] = note: `--force-warn edition-2024-expr-fragment-specifier` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 721 | ($fmt:literal $(,)? $($arg:expr_2021),* $(,)?) => {{ [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:83:15 [INFO] [stdout] | [INFO] [stdout] 83 | #[cfg(not(unstable))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:106:11 [INFO] [stdout] | [INFO] [stdout] 106 | #[cfg(unstable)] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:3:15 [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:3:44 [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:5:7 [INFO] [stdout] | [INFO] [stdout] 5 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 5 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:7:7 [INFO] [stdout] | [INFO] [stdout] 7 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 7 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:32:9 [INFO] [stdout] | [INFO] [stdout] 32 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:29:5 [INFO] [stdout] | [INFO] [stdout] 29 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> *const T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = note: `--force-warn unsafe-op-in-unsafe-fn` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:32:10 [INFO] [stdout] | [INFO] [stdout] 32 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | _______________^ [INFO] [stdout] 50 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 51 | | mem::size_of::() as u32, [INFO] [stdout] 52 | | src as *const c_void, [INFO] [stdout] 53 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:47:1 [INFO] [stdout] | [INFO] [stdout] 47 | pub unsafe fn bpf_probe_read(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:55:12 [INFO] [stdout] | [INFO] [stdout] 55 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | _______________^ [INFO] [stdout] 86 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 87 | | dst.len() as u32, [INFO] [stdout] 88 | | src as *const c_void, [INFO] [stdout] 89 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:84:1 [INFO] [stdout] | [INFO] [stdout] 84 | pub unsafe fn bpf_probe_read_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 123 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 124 | | mem::size_of::() as u32, [INFO] [stdout] 125 | | src as *const c_void, [INFO] [stdout] 126 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:120:1 [INFO] [stdout] | [INFO] [stdout] 120 | pub unsafe fn bpf_probe_read_user(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:128:12 [INFO] [stdout] | [INFO] [stdout] 128 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 157 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 158 | | dst.len() as u32, [INFO] [stdout] 159 | | src as *const c_void, [INFO] [stdout] 160 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:155:1 [INFO] [stdout] | [INFO] [stdout] 155 | pub unsafe fn bpf_probe_read_user_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | _______________^ [INFO] [stdout] 194 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 195 | | mem::size_of::() as u32, [INFO] [stdout] 196 | | src as *const c_void, [INFO] [stdout] 197 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:191:1 [INFO] [stdout] | [INFO] [stdout] 191 | pub unsafe fn bpf_probe_read_kernel(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:199:12 [INFO] [stdout] | [INFO] [stdout] 199 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | _______________^ [INFO] [stdout] 228 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 229 | | dst.len() as u32, [INFO] [stdout] 230 | | src as *const c_void, [INFO] [stdout] 231 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:226:1 [INFO] [stdout] | [INFO] [stdout] 226 | pub unsafe fn bpf_probe_read_kernel_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 271 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 272 | | dest.len() as u32, [INFO] [stdout] 273 | | src as *const c_void, [INFO] [stdout] 274 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:269:1 [INFO] [stdout] | [INFO] [stdout] 269 | pub unsafe fn bpf_probe_read_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 307 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 308 | | dest.len() as u32, [INFO] [stdout] 309 | | src as *const c_void, [INFO] [stdout] 310 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:305:1 [INFO] [stdout] | [INFO] [stdout] 305 | pub unsafe fn bpf_probe_read_user_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 405 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 406 | | dest.len() as u32, [INFO] [stdout] 407 | | src as *const c_void, [INFO] [stdout] 408 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:400:1 [INFO] [stdout] | [INFO] [stdout] 400 | / pub unsafe fn bpf_probe_read_user_str_bytes( [INFO] [stdout] 401 | | src: *const u8, [INFO] [stdout] 402 | | dest: &mut [u8], [INFO] [stdout] 403 | | ) -> Result<&[u8], c_long> { [INFO] [stdout] | |__________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 457 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 458 | | dest.len() as u32, [INFO] [stdout] 459 | | src as *const c_void, [INFO] [stdout] 460 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:455:1 [INFO] [stdout] | [INFO] [stdout] 455 | pub unsafe fn bpf_probe_read_kernel_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 556 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 557 | | dest.len() as u32, [INFO] [stdout] 558 | | src as *const c_void, [INFO] [stdout] 559 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:551:1 [INFO] [stdout] | [INFO] [stdout] 551 | / pub unsafe fn bpf_probe_read_kernel_str_bytes( [INFO] [stdout] 552 | | src: *const u8, [INFO] [stdout] 553 | | dest: &mut [u8], [INFO] [stdout] 554 | | ) -> Result<&[u8], c_long> { [INFO] [stdout] | |__________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_write_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 591 | | dst as *mut c_void, [INFO] [stdout] 592 | | src as *const c_void, [INFO] [stdout] 593 | | mem::size_of::() as u32, [INFO] [stdout] 594 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:589:1 [INFO] [stdout] | [INFO] [stdout] 589 | pub unsafe fn bpf_probe_write_user(dst: *mut T, src: *const T) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::intrinsics::transmute` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:826:9 [INFO] [stdout] | [INFO] [stdout] 826 | mem::transmute(6usize); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:817:1 [INFO] [stdout] | [INFO] [stdout] 817 | / pub unsafe fn bpf_printk_impl( [INFO] [stdout] 818 | | fmt: &[u8; FMT_LEN], [INFO] [stdout] 819 | | args: &[PrintkArg; NUM_ARGS], [INFO] [stdout] 820 | | ) -> i64 { [INFO] [stdout] | |________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:832:14 [INFO] [stdout] | [INFO] [stdout] 832 | 0 => printk(fmt_ptr, fmt_size), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:833:14 [INFO] [stdout] | [INFO] [stdout] 833 | 1 => printk(fmt_ptr, fmt_size, args[0]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:834:14 [INFO] [stdout] | [INFO] [stdout] 834 | 2 => printk(fmt_ptr, fmt_size, args[0], args[1]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:835:14 [INFO] [stdout] | [INFO] [stdout] 835 | 3 => printk(fmt_ptr, fmt_size, args[0], args[1], args[2]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_trace_vprintk` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_map_lookup_elem` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/array.rs:68:19 [INFO] [stdout] | [INFO] [stdout] 68 | let ptr = bpf_map_lookup_elem( [INFO] [stdout] | ___________________^ [INFO] [stdout] 69 | | self.def.get() as *mut _, [INFO] [stdout] 70 | | &index as *const _ as *const c_void, [INFO] [stdout] 71 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/array.rs:67:5 [INFO] [stdout] | [INFO] [stdout] 67 | unsafe fn lookup(&self, index: u32) -> Option> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:57:9 [INFO] [stdout] | [INFO] [stdout] 57 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:56:5 [INFO] [stdout] | [INFO] [stdout] 56 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:131:9 [INFO] [stdout] | [INFO] [stdout] 131 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:130:5 [INFO] [stdout] | [INFO] [stdout] 130 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:205:9 [INFO] [stdout] | [INFO] [stdout] 205 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:204:5 [INFO] [stdout] | [INFO] [stdout] 204 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:279:9 [INFO] [stdout] | [INFO] [stdout] 279 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:278:5 [INFO] [stdout] | [INFO] [stdout] 278 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:338:32 [INFO] [stdout] | [INFO] [stdout] 338 | get_ptr(def, key).map(|p| &*p) [INFO] [stdout] | ^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:337:1 [INFO] [stdout] | [INFO] [stdout] 337 | unsafe fn get<'a, K, V>(def: *mut bpf_map_def, key: &K) -> Option<&'a V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_map_lookup_elem` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/per_cpu_array.rs:70:19 [INFO] [stdout] | [INFO] [stdout] 70 | let ptr = bpf_map_lookup_elem( [INFO] [stdout] | ___________________^ [INFO] [stdout] 71 | | self.def.get() as *mut _, [INFO] [stdout] 72 | | &index as *const _ as *const c_void, [INFO] [stdout] 73 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/per_cpu_array.rs:69:5 [INFO] [stdout] | [INFO] [stdout] 69 | unsafe fn lookup(&self, index: u32) -> Option> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_tail_call` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/program_array.rs:108:19 [INFO] [stdout] | [INFO] [stdout] 108 | let res = bpf_tail_call(ctx.as_ptr(), self.def.get() as *mut _, index); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/program_array.rs:107:5 [INFO] [stdout] | [INFO] [stdout] 107 | pub unsafe fn tail_call(&self, ctx: &C, index: u32) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::hint::unreachable_unchecked` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/program_array.rs:112:13 [INFO] [stdout] | [INFO] [stdout] 112 | unreachable_unchecked() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_sock_map_update` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:58:19 [INFO] [stdout] | [INFO] [stdout] 58 | let ret = bpf_sock_map_update( [INFO] [stdout] | ___________________^ [INFO] [stdout] 59 | | sk_ops, [INFO] [stdout] 60 | | self.def.get() as *mut _, [INFO] [stdout] 61 | | &mut index as *mut _ as *mut c_void, [INFO] [stdout] 62 | | flags, [INFO] [stdout] 63 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:52:5 [INFO] [stdout] | [INFO] [stdout] 52 | / pub unsafe fn update( [INFO] [stdout] 53 | | &self, [INFO] [stdout] 54 | | mut index: u32, [INFO] [stdout] 55 | | sk_ops: *mut bpf_sock_ops, [INFO] [stdout] 56 | | flags: u64, [INFO] [stdout] 57 | | ) -> Result<(), i64> { [INFO] [stdout] | |________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_msg_redirect_map` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:72:9 [INFO] [stdout] | [INFO] [stdout] 72 | / bpf_msg_redirect_map( [INFO] [stdout] 73 | | ctx.as_ptr() as *mut _, [INFO] [stdout] 74 | | self.def.get() as *mut _, [INFO] [stdout] 75 | | index, [INFO] [stdout] 76 | | flags, [INFO] [stdout] 77 | | ) [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:71:5 [INFO] [stdout] | [INFO] [stdout] 71 | pub unsafe fn redirect_msg(&self, ctx: &SkMsgContext, index: u32, flags: u64) -> i64 { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_sk_redirect_map` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:81:9 [INFO] [stdout] | [INFO] [stdout] 81 | / bpf_sk_redirect_map( [INFO] [stdout] 82 | | ctx.as_ptr() as *mut _, [INFO] [stdout] 83 | | self.def.get() as *mut _, [INFO] [stdout] 84 | | index, [INFO] [stdout] 85 | | flags, [INFO] [stdout] 86 | | ) [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:80:5 [INFO] [stdout] | [INFO] [stdout] 80 | pub unsafe fn redirect_skb(&self, ctx: &SkBuffContext, index: u32, flags: u64) -> i64 { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_get_stackid` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/stack_trace.rs:49:19 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = bpf_get_stackid(ctx.as_ptr(), self.def.get() as *mut _, flags); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/stack_trace.rs:48:5 [INFO] [stdout] | [INFO] [stdout] 48 | pub unsafe fn get_stackid(&self, ctx: &C, flags: u64) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/fentry.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/fentry.rs:34:5 [INFO] [stdout] | [INFO] [stdout] 34 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/fexit.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/fexit.rs:34:5 [INFO] [stdout] | [INFO] [stdout] 34 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/lsm.rs:54:9 [INFO] [stdout] | [INFO] [stdout] 54 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/lsm.rs:53:5 [INFO] [stdout] | [INFO] [stdout] 53 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tp_btf.rs:44:9 [INFO] [stdout] | [INFO] [stdout] 44 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/tp_btf.rs:43:5 [INFO] [stdout] | [INFO] [stdout] 43 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tracepoint.rs:15:9 [INFO] [stdout] | [INFO] [stdout] 15 | bpf_probe_read(self.ctx.add(offset) as *const T) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/tracepoint.rs:14:5 [INFO] [stdout] | [INFO] [stdout] 14 | pub unsafe fn read_at(&self, offset: usize) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tracepoint.rs:15:24 [INFO] [stdout] | [INFO] [stdout] 15 | bpf_probe_read(self.ctx.add(offset) as *const T) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:69:9 [INFO] [stdout] | [INFO] [stdout] 69 | *s.add(i) = b; [INFO] [stdout] | ^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/lib.rs:65:1 [INFO] [stdout] | [INFO] [stdout] 65 | pub unsafe extern "C" fn memset(s: *mut u8, c: c_int, n: usize) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:69:10 [INFO] [stdout] | [INFO] [stdout] 69 | *s.add(i) = b; [INFO] [stdout] | ^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:9 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/lib.rs:74:1 [INFO] [stdout] | [INFO] [stdout] 74 | pub unsafe extern "C" fn memcpy(dest: *mut u8, src: *mut u8, n: usize) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:10 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:24 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:25 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: 148 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] For more information about this error, try `rustc --explain E0133`. [INFO] [stdout] [INFO] [stderr] warning: failed to automatically apply fixes suggested by rustc to crate `aya_ebpf` [INFO] [stderr] [INFO] [stderr] after fixes were automatically applied the compiler reported errors within these files: [INFO] [stderr] [INFO] [stderr] * src/args.rs [INFO] [stderr] * src/helpers.rs [INFO] [stderr] * src/lib.rs [INFO] [stderr] * src/maps/program_array.rs [INFO] [stderr] * src/programs/probe.rs [INFO] [stderr] [INFO] [stderr] This likely indicates a bug in either rustc or cargo itself, [INFO] [stderr] and we would appreciate a bug report! You're likely to see [INFO] [stderr] a number of compiler warnings after this message which cargo [INFO] [stderr] attempted to fix but failed. If you could open an issue at [INFO] [stderr] https://github.com/rust-lang/rust/issues [INFO] [stderr] quoting the full output of this command we'd be very appreciative! [INFO] [stderr] Note that you may be able to make some more progress in the near-term [INFO] [stderr] fixing code with the `--broken-code` flag [INFO] [stderr] [INFO] [stderr] The following errors were reported: [INFO] [stderr] error[E0658]: fragment specifier `expr_2021` is unstable [INFO] [stderr] --> src/helpers.rs:721:27 [INFO] [stderr] | [INFO] [stderr] 721 | ($fmt:literal $(,)? $($arg:expr_2021),* $(,)?) => {{ [INFO] [stderr] | ^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = note: see issue #123742 for more information [INFO] [stderr] = help: add `#![feature(expr_fragment_specifier_2024)]` to the crate attributes to enable [INFO] [stderr] = note: this compiler was built on 2024-09-17; consider upgrading it if it is out of date [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/lib.rs:16:13 [INFO] [stderr] | [INFO] [stderr] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:2:15 [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:2:44 [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:4:7 [INFO] [stderr] | [INFO] [stderr] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:6:7 [INFO] [stderr] | [INFO] [stderr] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:101:7 [INFO] [stderr] | [INFO] [stderr] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:120:7 [INFO] [stderr] | [INFO] [stderr] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 120 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:135:7 [INFO] [stderr] | [INFO] [stderr] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:150:7 [INFO] [stderr] | [INFO] [stderr] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:171:7 [INFO] [stderr] | [INFO] [stderr] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:190:7 [INFO] [stderr] | [INFO] [stderr] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 190 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:205:7 [INFO] [stderr] | [INFO] [stderr] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:220:7 [INFO] [stderr] | [INFO] [stderr] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 316 | impl_from_pt_regs!(u8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 317 | impl_from_pt_regs!(u16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 318 | impl_from_pt_regs!(u32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 319 | impl_from_pt_regs!(u64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 320 | impl_from_pt_regs!(i8); [INFO] [stderr] | ---------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 321 | impl_from_pt_regs!(i16); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 322 | impl_from_pt_regs!(i32); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 323 | impl_from_pt_regs!(i64); [INFO] [stderr] | ----------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 324 | impl_from_pt_regs!(usize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:244:15 [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:263:15 [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 263 | #[cfg(target_arch = "arm")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:278:15 [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/args.rs:293:15 [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] ... [INFO] [stderr] 325 | impl_from_pt_regs!(isize); [INFO] [stderr] | ------------------------- in this macro invocation [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/maps/program_array.rs:83:15 [INFO] [stderr] | [INFO] [stderr] 83 | #[cfg(not(unstable))] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `unstable` [INFO] [stderr] --> src/maps/program_array.rs:106:11 [INFO] [stderr] | [INFO] [stderr] 106 | #[cfg(unstable)] [INFO] [stderr] | ^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:3:15 [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:3:44 [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:5:7 [INFO] [stderr] | [INFO] [stderr] 5 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 5 | #[cfg(target_arch = "aarch64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stderr] --> src/programs/probe.rs:7:7 [INFO] [stderr] | [INFO] [stderr] 7 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stderr] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stderr] | [INFO] [stderr] = help: consider using a Cargo feature instead [INFO] [stderr] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stderr] [lints.rust] [INFO] [stderr] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stderr] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stderr] = note: see for more information about checking conditional configuration [INFO] [stderr] help: there is a config with a similar name and value [INFO] [stderr] | [INFO] [stderr] 7 | #[cfg(target_arch = "riscv64")] [INFO] [stderr] | ~~~~~~~~~~~ [INFO] [stderr] [INFO] [stderr] error: aborting due to 1 previous error; 59 warnings emitted [INFO] [stderr] [INFO] [stderr] For more information about this error, try `rustc --explain E0658`. [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:12:39 [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as gen; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] = note: `--force-warn keyword-idents-2024` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] Original diagnostics will follow. [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:14:9 [INFO] [stdout] | [INFO] [stdout] 14 | pub use gen::*; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:621:24 [INFO] [stdout] | [INFO] [stdout] 621 | let ret = unsafe { gen::bpf_get_current_comm(&mut comm as *mut _ as *mut c_void, 16u32) }; [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:654:14 [INFO] [stdout] | [INFO] [stdout] 654 | unsafe { gen::bpf_get_current_pid_tgid() } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:677:14 [INFO] [stdout] | [INFO] [stdout] 677 | unsafe { gen::bpf_get_current_uid_gid() } [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: `gen` is a keyword in the 2024 edition [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | ^^^ help: you can use a raw identifier to stay compatible: `r#gen` [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #49716 [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/lib.rs:16:13 [INFO] [stdout] | [INFO] [stdout] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:64:3 [INFO] [stdout] | [INFO] [stdout] 64 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] = note: `--force-warn unsafe-attr-outside-unsafe` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 64 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:73:3 [INFO] [stdout] | [INFO] [stdout] 73 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] = warning: this is accepted in the current edition (Rust 2021) but is a hard error in Rust 2024! [INFO] [stdout] = note: for more information, see issue #123757 [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 73 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:15 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:44 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:4:7 [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:6:7 [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:101:7 [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:120:7 [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:135:7 [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:150:7 [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:171:7 [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:190:7 [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:205:7 [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:220:7 [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the `expr` fragment specifier will accept more expressions in the 2024 edition [INFO] [stdout] --> src/helpers.rs:721:32 [INFO] [stdout] | [INFO] [stdout] 721 | ($fmt:literal $(,)? $($arg:expr),* $(,)?) => {{ [INFO] [stdout] | ^^^^ [INFO] [stdout] | [INFO] [stdout] = warning: this changes meaning in Rust 2024 [INFO] [stdout] = note: for more information, see Migration Guide [INFO] [stdout] = note: `--force-warn edition-2024-expr-fragment-specifier` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] help: to keep the existing behavior, use the `expr_2021` fragment specifier [INFO] [stdout] | [INFO] [stdout] 721 | ($fmt:literal $(,)? $($arg:expr_2021),* $(,)?) => {{ [INFO] [stdout] | ~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:83:15 [INFO] [stdout] | [INFO] [stdout] 83 | #[cfg(not(unstable))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:106:11 [INFO] [stdout] | [INFO] [stdout] 106 | #[cfg(unstable)] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:3:15 [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:3:44 [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 3 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:5:7 [INFO] [stdout] | [INFO] [stdout] 5 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 5 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/programs/probe.rs:7:7 [INFO] [stdout] | [INFO] [stdout] 7 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 7 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:32:9 [INFO] [stdout] | [INFO] [stdout] 32 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:29:5 [INFO] [stdout] | [INFO] [stdout] 29 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> *const T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] = note: `--force-warn unsafe-op-in-unsafe-fn` implied by `--force-warn rust-2024-compatibility` [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:32:10 [INFO] [stdout] | [INFO] [stdout] 32 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 49 | unsafe_impl_from_btf_argument!(u8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 50 | unsafe_impl_from_btf_argument!(u16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 51 | unsafe_impl_from_btf_argument!(u32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 52 | unsafe_impl_from_btf_argument!(u64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 53 | unsafe_impl_from_btf_argument!(i8); [INFO] [stdout] | ---------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 54 | unsafe_impl_from_btf_argument!(i16); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 55 | unsafe_impl_from_btf_argument!(i32); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 56 | unsafe_impl_from_btf_argument!(i64); [INFO] [stdout] | ----------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 57 | unsafe_impl_from_btf_argument!(usize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:17 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/args.rs:40:13 [INFO] [stdout] | [INFO] [stdout] 40 | unsafe fn from_argument(ctx: *const c_void, n: usize) -> Self { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::const_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/args.rs:43:18 [INFO] [stdout] | [INFO] [stdout] 43 | *(ctx as *const usize).add(n) as _ [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] ... [INFO] [stdout] 58 | unsafe_impl_from_btf_argument!(isize); [INFO] [stdout] | ------------------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] = note: this warning originates in the macro `unsafe_impl_from_btf_argument` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | _______________^ [INFO] [stdout] 50 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 51 | | mem::size_of::() as u32, [INFO] [stdout] 52 | | src as *const c_void, [INFO] [stdout] 53 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:47:1 [INFO] [stdout] | [INFO] [stdout] 47 | pub unsafe fn bpf_probe_read(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:55:12 [INFO] [stdout] | [INFO] [stdout] 55 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | _______________^ [INFO] [stdout] 86 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 87 | | dst.len() as u32, [INFO] [stdout] 88 | | src as *const c_void, [INFO] [stdout] 89 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:84:1 [INFO] [stdout] | [INFO] [stdout] 84 | pub unsafe fn bpf_probe_read_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 123 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 124 | | mem::size_of::() as u32, [INFO] [stdout] 125 | | src as *const c_void, [INFO] [stdout] 126 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:120:1 [INFO] [stdout] | [INFO] [stdout] 120 | pub unsafe fn bpf_probe_read_user(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:128:12 [INFO] [stdout] | [INFO] [stdout] 128 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 157 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 158 | | dst.len() as u32, [INFO] [stdout] 159 | | src as *const c_void, [INFO] [stdout] 160 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:155:1 [INFO] [stdout] | [INFO] [stdout] 155 | pub unsafe fn bpf_probe_read_user_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | _______________^ [INFO] [stdout] 194 | | v.as_mut_ptr() as *mut c_void, [INFO] [stdout] 195 | | mem::size_of::() as u32, [INFO] [stdout] 196 | | src as *const c_void, [INFO] [stdout] 197 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:191:1 [INFO] [stdout] | [INFO] [stdout] 191 | pub unsafe fn bpf_probe_read_kernel(src: *const T) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::mem::MaybeUninit::::assume_init` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:199:12 [INFO] [stdout] | [INFO] [stdout] 199 | Ok(v.assume_init()) [INFO] [stdout] | ^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | _______________^ [INFO] [stdout] 228 | | dst.as_mut_ptr() as *mut c_void, [INFO] [stdout] 229 | | dst.len() as u32, [INFO] [stdout] 230 | | src as *const c_void, [INFO] [stdout] 231 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:226:1 [INFO] [stdout] | [INFO] [stdout] 226 | pub unsafe fn bpf_probe_read_kernel_buf(src: *const u8, dst: &mut [u8]) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 271 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 272 | | dest.len() as u32, [INFO] [stdout] 273 | | src as *const c_void, [INFO] [stdout] 274 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:269:1 [INFO] [stdout] | [INFO] [stdout] 269 | pub unsafe fn bpf_probe_read_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 307 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 308 | | dest.len() as u32, [INFO] [stdout] 309 | | src as *const c_void, [INFO] [stdout] 310 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:305:1 [INFO] [stdout] | [INFO] [stdout] 305 | pub unsafe fn bpf_probe_read_user_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_user_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 405 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 406 | | dest.len() as u32, [INFO] [stdout] 407 | | src as *const c_void, [INFO] [stdout] 408 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:400:1 [INFO] [stdout] | [INFO] [stdout] 400 | / pub unsafe fn bpf_probe_read_user_str_bytes( [INFO] [stdout] 401 | | src: *const u8, [INFO] [stdout] 402 | | dest: &mut [u8], [INFO] [stdout] 403 | | ) -> Result<&[u8], c_long> { [INFO] [stdout] | |__________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 457 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 458 | | dest.len() as u32, [INFO] [stdout] 459 | | src as *const c_void, [INFO] [stdout] 460 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:455:1 [INFO] [stdout] | [INFO] [stdout] 455 | pub unsafe fn bpf_probe_read_kernel_str(src: *const u8, dest: &mut [u8]) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_read_kernel_str` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | _______________^ [INFO] [stdout] 556 | | dest.as_mut_ptr() as *mut c_void, [INFO] [stdout] 557 | | dest.len() as u32, [INFO] [stdout] 558 | | src as *const c_void, [INFO] [stdout] 559 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:551:1 [INFO] [stdout] | [INFO] [stdout] 551 | / pub unsafe fn bpf_probe_read_kernel_str_bytes( [INFO] [stdout] 552 | | src: *const u8, [INFO] [stdout] 553 | | dest: &mut [u8], [INFO] [stdout] 554 | | ) -> Result<&[u8], c_long> { [INFO] [stdout] | |__________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_probe_write_user` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | _______________^ [INFO] [stdout] 591 | | dst as *mut c_void, [INFO] [stdout] 592 | | src as *const c_void, [INFO] [stdout] 593 | | mem::size_of::() as u32, [INFO] [stdout] 594 | | ); [INFO] [stdout] | |_____^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:589:1 [INFO] [stdout] | [INFO] [stdout] 589 | pub unsafe fn bpf_probe_write_user(dst: *mut T, src: *const T) -> Result<(), c_long> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::intrinsics::transmute` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:826:9 [INFO] [stdout] | [INFO] [stdout] 826 | mem::transmute(6usize); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/helpers.rs:817:1 [INFO] [stdout] | [INFO] [stdout] 817 | / pub unsafe fn bpf_printk_impl( [INFO] [stdout] 818 | | fmt: &[u8; FMT_LEN], [INFO] [stdout] 819 | | args: &[PrintkArg; NUM_ARGS], [INFO] [stdout] 820 | | ) -> i64 { [INFO] [stdout] | |________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:832:14 [INFO] [stdout] | [INFO] [stdout] 832 | 0 => printk(fmt_ptr, fmt_size), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:833:14 [INFO] [stdout] | [INFO] [stdout] 833 | 1 => printk(fmt_ptr, fmt_size, args[0]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:834:14 [INFO] [stdout] | [INFO] [stdout] 834 | 2 => printk(fmt_ptr, fmt_size, args[0], args[1]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:835:14 [INFO] [stdout] | [INFO] [stdout] 835 | 3 => printk(fmt_ptr, fmt_size, args[0], args[1], args[2]), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_trace_vprintk` is unsafe and requires unsafe block [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_map_lookup_elem` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/array.rs:68:19 [INFO] [stdout] | [INFO] [stdout] 68 | let ptr = bpf_map_lookup_elem( [INFO] [stdout] | ___________________^ [INFO] [stdout] 69 | | self.def.get() as *mut _, [INFO] [stdout] 70 | | &index as *const _ as *const c_void, [INFO] [stdout] 71 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/array.rs:67:5 [INFO] [stdout] | [INFO] [stdout] 67 | unsafe fn lookup(&self, index: u32) -> Option> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:57:9 [INFO] [stdout] | [INFO] [stdout] 57 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:56:5 [INFO] [stdout] | [INFO] [stdout] 56 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:131:9 [INFO] [stdout] | [INFO] [stdout] 131 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:130:5 [INFO] [stdout] | [INFO] [stdout] 130 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:205:9 [INFO] [stdout] | [INFO] [stdout] 205 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:204:5 [INFO] [stdout] | [INFO] [stdout] 204 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `maps::hash_map::get` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:279:9 [INFO] [stdout] | [INFO] [stdout] 279 | get(self.def.get(), key) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:278:5 [INFO] [stdout] | [INFO] [stdout] 278 | pub unsafe fn get(&self, key: &K) -> Option<&V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/hash_map.rs:338:32 [INFO] [stdout] | [INFO] [stdout] 338 | get_ptr(def, key).map(|p| &*p) [INFO] [stdout] | ^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/hash_map.rs:337:1 [INFO] [stdout] | [INFO] [stdout] 337 | unsafe fn get<'a, K, V>(def: *mut bpf_map_def, key: &K) -> Option<&'a V> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_map_lookup_elem` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/per_cpu_array.rs:70:19 [INFO] [stdout] | [INFO] [stdout] 70 | let ptr = bpf_map_lookup_elem( [INFO] [stdout] | ___________________^ [INFO] [stdout] 71 | | self.def.get() as *mut _, [INFO] [stdout] 72 | | &index as *const _ as *const c_void, [INFO] [stdout] 73 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/per_cpu_array.rs:69:5 [INFO] [stdout] | [INFO] [stdout] 69 | unsafe fn lookup(&self, index: u32) -> Option> { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_tail_call` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/program_array.rs:108:19 [INFO] [stdout] | [INFO] [stdout] 108 | let res = bpf_tail_call(ctx.as_ptr(), self.def.get() as *mut _, index); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/program_array.rs:107:5 [INFO] [stdout] | [INFO] [stdout] 107 | pub unsafe fn tail_call(&self, ctx: &C, index: u32) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::hint::unreachable_unchecked` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/program_array.rs:112:13 [INFO] [stdout] | [INFO] [stdout] 112 | unreachable_unchecked() [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_sock_map_update` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:58:19 [INFO] [stdout] | [INFO] [stdout] 58 | let ret = bpf_sock_map_update( [INFO] [stdout] | ___________________^ [INFO] [stdout] 59 | | sk_ops, [INFO] [stdout] 60 | | self.def.get() as *mut _, [INFO] [stdout] 61 | | &mut index as *mut _ as *mut c_void, [INFO] [stdout] 62 | | flags, [INFO] [stdout] 63 | | ); [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:52:5 [INFO] [stdout] | [INFO] [stdout] 52 | / pub unsafe fn update( [INFO] [stdout] 53 | | &self, [INFO] [stdout] 54 | | mut index: u32, [INFO] [stdout] 55 | | sk_ops: *mut bpf_sock_ops, [INFO] [stdout] 56 | | flags: u64, [INFO] [stdout] 57 | | ) -> Result<(), i64> { [INFO] [stdout] | |________________________^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_msg_redirect_map` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:72:9 [INFO] [stdout] | [INFO] [stdout] 72 | / bpf_msg_redirect_map( [INFO] [stdout] 73 | | ctx.as_ptr() as *mut _, [INFO] [stdout] 74 | | self.def.get() as *mut _, [INFO] [stdout] 75 | | index, [INFO] [stdout] 76 | | flags, [INFO] [stdout] 77 | | ) [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:71:5 [INFO] [stdout] | [INFO] [stdout] 71 | pub unsafe fn redirect_msg(&self, ctx: &SkMsgContext, index: u32, flags: u64) -> i64 { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_sk_redirect_map` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/sock_map.rs:81:9 [INFO] [stdout] | [INFO] [stdout] 81 | / bpf_sk_redirect_map( [INFO] [stdout] 82 | | ctx.as_ptr() as *mut _, [INFO] [stdout] 83 | | self.def.get() as *mut _, [INFO] [stdout] 84 | | index, [INFO] [stdout] 85 | | flags, [INFO] [stdout] 86 | | ) [INFO] [stdout] | |_________^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/sock_map.rs:80:5 [INFO] [stdout] | [INFO] [stdout] 80 | pub unsafe fn redirect_skb(&self, ctx: &SkBuffContext, index: u32, flags: u64) -> i64 { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `aya_ebpf_bindings::helpers::bpf_get_stackid` is unsafe and requires unsafe block [INFO] [stdout] --> src/maps/stack_trace.rs:49:19 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = bpf_get_stackid(ctx.as_ptr(), self.def.get() as *mut _, flags); [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/maps/stack_trace.rs:48:5 [INFO] [stdout] | [INFO] [stdout] 48 | pub unsafe fn get_stackid(&self, ctx: &C, flags: u64) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/fentry.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/fentry.rs:34:5 [INFO] [stdout] | [INFO] [stdout] 34 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/fexit.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/fexit.rs:34:5 [INFO] [stdout] | [INFO] [stdout] 34 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/lsm.rs:54:9 [INFO] [stdout] | [INFO] [stdout] 54 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/lsm.rs:53:5 [INFO] [stdout] | [INFO] [stdout] 53 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `args::FromBtfArgument::from_argument` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tp_btf.rs:44:9 [INFO] [stdout] | [INFO] [stdout] 44 | T::from_argument(self.ctx as *const _, n) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/tp_btf.rs:43:5 [INFO] [stdout] | [INFO] [stdout] 43 | pub unsafe fn arg(&self, n: usize) -> T { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `helpers::bpf_probe_read` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tracepoint.rs:15:9 [INFO] [stdout] | [INFO] [stdout] 15 | bpf_probe_read(self.ctx.add(offset) as *const T) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/programs/tracepoint.rs:14:5 [INFO] [stdout] | [INFO] [stdout] 14 | pub unsafe fn read_at(&self, offset: usize) -> Result { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/programs/tracepoint.rs:15:24 [INFO] [stdout] | [INFO] [stdout] 15 | bpf_probe_read(self.ctx.add(offset) as *const T) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:69:9 [INFO] [stdout] | [INFO] [stdout] 69 | *s.add(i) = b; [INFO] [stdout] | ^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/lib.rs:65:1 [INFO] [stdout] | [INFO] [stdout] 65 | pub unsafe extern "C" fn memset(s: *mut u8, c: c_int, n: usize) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:69:10 [INFO] [stdout] | [INFO] [stdout] 69 | *s.add(i) = b; [INFO] [stdout] | ^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:9 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] note: an unsafe function restricts its caller, but its body is safe by default [INFO] [stdout] --> src/lib.rs:74:1 [INFO] [stdout] | [INFO] [stdout] 74 | pub unsafe extern "C" fn memcpy(dest: *mut u8, src: *mut u8, n: usize) { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:10 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:24 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^^ dereference of raw pointer [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning[E0133]: call to unsafe function `core::ptr::mut_ptr::::add` is unsafe and requires unsafe block [INFO] [stdout] --> src/lib.rs:76:25 [INFO] [stdout] | [INFO] [stdout] 76 | *dest.add(i) = *src.add(i); [INFO] [stdout] | ^^^^^^^^^^ call to unsafe function [INFO] [stdout] | [INFO] [stdout] = note: for more information, see issue #71668 [INFO] [stdout] = note: consult the function's documentation for information on how to avoid undefined behavior [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: 148 warnings emitted [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] For more information about this error, try `rustc --explain E0133`. [INFO] [stdout] [INFO] [stderr] Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.90s [INFO] [stderr] Running `cargo check` to verify 2024 [INFO] [stderr] Compiling aya-ebpf v0.1.0 (/tmp/fixit) [INFO] [stdout] error: expected identifier, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:12:39 [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as gen; [INFO] [stdout] | ^^^ expected identifier, found reserved keyword [INFO] [stdout] | [INFO] [stdout] help: escape `gen` to use it as an identifier [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as r#gen; [INFO] [stdout] | ++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected identifier, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:12:39 [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as gen; [INFO] [stdout] | ^^^ expected identifier, found reserved keyword [INFO] [stdout] | [INFO] [stdout] help: escape `gen` to use it as an identifier [INFO] [stdout] | [INFO] [stdout] 12 | pub use aya_ebpf_bindings::helpers as r#gen; [INFO] [stdout] | ++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected identifier, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:14:9 [INFO] [stdout] | [INFO] [stdout] 14 | pub use gen::*; [INFO] [stdout] | ^^^ expected identifier, found reserved keyword [INFO] [stdout] | [INFO] [stdout] help: escape `gen` to use it as an identifier [INFO] [stdout] | [INFO] [stdout] 14 | pub use r#gen::*; [INFO] [stdout] | ++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected identifier, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:14:9 [INFO] [stdout] | [INFO] [stdout] 14 | pub use gen::*; [INFO] [stdout] | ^^^ expected identifier, found reserved keyword [INFO] [stdout] | [INFO] [stdout] help: escape `gen` to use it as an identifier [INFO] [stdout] | [INFO] [stdout] 14 | pub use r#gen::*; [INFO] [stdout] | ++ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:49:15 [INFO] [stdout] | [INFO] [stdout] 49 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:85:15 [INFO] [stdout] | [INFO] [stdout] 85 | let ret = gen::bpf_probe_read( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:122:15 [INFO] [stdout] | [INFO] [stdout] 122 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:156:15 [INFO] [stdout] | [INFO] [stdout] 156 | let ret = gen::bpf_probe_read_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:193:15 [INFO] [stdout] | [INFO] [stdout] 193 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:227:15 [INFO] [stdout] | [INFO] [stdout] 227 | let ret = gen::bpf_probe_read_kernel( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:270:15 [INFO] [stdout] | [INFO] [stdout] 270 | let len = gen::bpf_probe_read_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:306:15 [INFO] [stdout] | [INFO] [stdout] 306 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:404:15 [INFO] [stdout] | [INFO] [stdout] 404 | let len = gen::bpf_probe_read_user_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:456:15 [INFO] [stdout] | [INFO] [stdout] 456 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:555:15 [INFO] [stdout] | [INFO] [stdout] 555 | let len = gen::bpf_probe_read_kernel_str( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:590:15 [INFO] [stdout] | [INFO] [stdout] 590 | let ret = gen::bpf_probe_write_user( [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:621:24 [INFO] [stdout] | [INFO] [stdout] 621 | let ret = unsafe { gen::bpf_get_current_comm(&mut comm as *mut _ as *mut c_void, 16u32) }; [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:654:14 [INFO] [stdout] | [INFO] [stdout] 654 | unsafe { gen::bpf_get_current_pid_tgid() } [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:621:24 [INFO] [stdout] | [INFO] [stdout] 621 | let ret = unsafe { gen::bpf_get_current_comm(&mut comm as *mut _ as *mut c_void, 16u32) }; [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:677:14 [INFO] [stdout] | [INFO] [stdout] 677 | unsafe { gen::bpf_get_current_uid_gid() } [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:654:14 [INFO] [stdout] | [INFO] [stdout] 654 | unsafe { gen::bpf_get_current_pid_tgid() } [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:677:14 [INFO] [stdout] | [INFO] [stdout] 677 | unsafe { gen::bpf_get_current_uid_gid() } [INFO] [stdout] | ^^^ expected expression [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | -- ^^^ expected expression [INFO] [stdout] | | [INFO] [stdout] | while parsing the `match` arm starting here [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: expected expression, found reserved keyword `gen` [INFO] [stdout] --> src/helpers.rs:836:14 [INFO] [stdout] | [INFO] [stdout] 836 | _ => gen::bpf_trace_vprintk(fmt_ptr, fmt_size, args.as_ptr() as _, (NUM_ARGS * 8) as _), [INFO] [stdout] | -- ^^^ expected expression [INFO] [stdout] | | [INFO] [stdout] | while parsing the `match` arm starting here [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:64:3 [INFO] [stdout] | [INFO] [stdout] 64 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 64 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:73:3 [INFO] [stdout] | [INFO] [stdout] 73 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 73 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:64:3 [INFO] [stdout] | [INFO] [stdout] 64 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 64 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: unsafe attribute used without unsafe [INFO] [stdout] --> src/lib.rs:73:3 [INFO] [stdout] | [INFO] [stdout] 73 | #[no_mangle] [INFO] [stdout] | ^^^^^^^^^ usage of unsafe attribute [INFO] [stdout] | [INFO] [stdout] help: wrap the attribute in `unsafe(...)` [INFO] [stdout] | [INFO] [stdout] 73 | #[unsafe(no_mangle)] [INFO] [stdout] | +++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/lib.rs:16:13 [INFO] [stdout] | [INFO] [stdout] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:15 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:44 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:4:7 [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/lib.rs:16:13 [INFO] [stdout] | [INFO] [stdout] 16 | #![cfg_attr(unstable, feature(never_type))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: expected names are: `clippy`, `debug_assertions`, `doc`, `docsrs`, `doctest`, `feature`, `fmt_debug`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows` [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: `#[warn(unexpected_cfgs)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:6:7 [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:15 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:101:7 [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:2:44 [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", bpf_target_arch = "riscv64")))] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 2 | #[cfg(not(any(bpf_target_arch = "aarch64", target_arch = "riscv64")))] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:120:7 [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:4:7 [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 4 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:135:7 [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:6:7 [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 6 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:150:7 [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:101:7 [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 101 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:171:7 [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:120:7 [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 120 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:190:7 [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:135:7 [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 135 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:205:7 [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:150:7 [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 150 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:220:7 [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:171:7 [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 171 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:190:7 [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 190 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:205:7 [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 205 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:220:7 [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 220 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 316 | impl_from_pt_regs!(u8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 317 | impl_from_pt_regs!(u16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 318 | impl_from_pt_regs!(u32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 319 | impl_from_pt_regs!(u64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 320 | impl_from_pt_regs!(i8); [INFO] [stdout] | ---------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 321 | impl_from_pt_regs!(i16); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 322 | impl_from_pt_regs!(i32); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 323 | impl_from_pt_regs!(i64); [INFO] [stdout] | ----------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:244:15 [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(bpf_target_arch = "x86_64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("x86_64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"x86_64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 244 | #[cfg(target_arch = "x86_64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:263:15 [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(bpf_target_arch = "arm")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("arm"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"arm\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 263 | #[cfg(target_arch = "arm")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 325 | impl_from_pt_regs!(isize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:278:15 [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(bpf_target_arch = "aarch64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("aarch64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"aarch64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 278 | #[cfg(target_arch = "aarch64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `c_void` [INFO] [stdout] --> src/helpers.rs:18:27 [INFO] [stdout] | [INFO] [stdout] 18 | cty::{c_char, c_long, c_void}, [INFO] [stdout] | ^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_imports)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:83:15 [INFO] [stdout] | [INFO] [stdout] 83 | #[cfg(not(unstable))] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `bpf_target_arch` [INFO] [stdout] --> src/args.rs:293:15 [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(bpf_target_arch = "riscv64")] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 324 | impl_from_pt_regs!(usize); [INFO] [stdout] | ------------------------- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bpf_target_arch, values("riscv64"))'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bpf_target_arch, values(\"riscv64\"))");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [INFO] [stdout] = note: this warning originates in the macro `impl_from_pt_regs` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] help: there is a config with a similar name and value [INFO] [stdout] | [INFO] [stdout] 293 | #[cfg(target_arch = "riscv64")] [INFO] [stdout] | ~~~~~~~~~~~ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unexpected `cfg` condition name: `unstable` [INFO] [stdout] --> src/maps/program_array.rs:106:11 [INFO] [stdout] | [INFO] [stdout] 106 | #[cfg(unstable)] [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = help: consider using a Cargo feature instead [INFO] [stdout] = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint: [INFO] [stdout] [lints.rust] [INFO] [stdout] unexpected_cfgs = { level = "warn", check-cfg = ['cfg(unstable)'] } [INFO] [stdout] = help: or consider adding `println!("cargo::rustc-check-cfg=cfg(unstable)");` to the top of the `build.rs` [INFO] [stdout] = note: see for more information about checking conditional configuration [WARN] too many lines in the log, truncating it