[INFO] fetching crate lwext4-sys 0.1.0...
[INFO] checking lwext4-sys-0.1.0 against master#c2f2db79ca3024f68d22b45aa22b570775c2c4ad for pr-124157
[INFO] extracting crate lwext4-sys 0.1.0 into /workspace/builds/worker-1-tc1/source
[INFO] validating manifest of crates.io crate lwext4-sys 0.1.0 on toolchain c2f2db79ca3024f68d22b45aa22b570775c2c4ad
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate lwext4-sys 0.1.0
[INFO] finished tweaking crates.io crate lwext4-sys 0.1.0
[INFO] tweaked toml for crates.io crate lwext4-sys 0.1.0 written to /workspace/builds/worker-1-tc1/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 60 packages to latest compatible versions
[INFO] [stderr]       Adding bindgen v0.59.2 (latest: v0.69.4)
[INFO] [stderr]       Adding bitflags v1.3.2 (latest: v2.5.0)
[INFO] [stderr]       Adding clap v2.34.0 (latest: v4.5.4)
[INFO] [stderr]       Adding env_logger v0.9.3 (latest: v0.11.3)
[INFO] [stderr]       Adding hermit-abi v0.1.19 (latest: v0.3.9)
[INFO] [stderr]       Adding linux-raw-sys v0.4.13 (latest: v0.6.4)
[INFO] [stderr]       Adding peeking_take_while v0.1.2 (latest: v1.0.0)
[INFO] [stderr]       Adding strsim v0.8.0 (latest: v0.11.1)
[INFO] [stderr]       Adding textwrap v0.11.0 (latest: v0.16.1)
[INFO] [stderr]       Adding which v4.4.2 (latest: v6.0.1)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded make-cmd v0.1.0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 8656d83de7b37eacfafa44bb74824dc46ca292b6100cd95ab9f14524dd62bbde
[INFO] running `Command { std: "docker" "start" "-a" "8656d83de7b37eacfafa44bb74824dc46ca292b6100cd95ab9f14524dd62bbde", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8656d83de7b37eacfafa44bb74824dc46ca292b6100cd95ab9f14524dd62bbde", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "8656d83de7b37eacfafa44bb74824dc46ca292b6100cd95ab9f14524dd62bbde", kill_on_drop: false }`
[INFO] [stdout] 8656d83de7b37eacfafa44bb74824dc46ca292b6100cd95ab9f14524dd62bbde
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc1/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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 55cd19915121354c452b68759f447f2ba277b2a8283baac50a636b0a9b5fd200
[INFO] running `Command { std: "docker" "start" "-a" "55cd19915121354c452b68759f447f2ba277b2a8283baac50a636b0a9b5fd200", kill_on_drop: false }`
[INFO] [stderr]    Compiling aho-corasick v1.1.3
[INFO] [stderr]    Compiling proc-macro2 v1.0.81
[INFO] [stderr]    Compiling unicode-width v0.1.12
[INFO] [stderr]    Compiling atty v0.2.14
[INFO] [stderr]    Compiling termcolor v1.4.1
[INFO] [stderr]    Compiling log v0.4.21
[INFO] [stderr]    Compiling bitflags v1.3.2
[INFO] [stderr]    Compiling ansi_term v0.12.1
[INFO] [stderr]    Compiling vec_map v0.8.2
[INFO] [stderr]    Compiling strsim v0.8.0
[INFO] [stderr]    Compiling textwrap v0.11.0
[INFO] [stderr]    Compiling humantime v2.1.0
[INFO] [stderr]    Compiling bindgen v0.59.2
[INFO] [stderr]    Compiling make-cmd v0.1.0
[INFO] [stderr]    Compiling clap v2.34.0
[INFO] [stderr]    Compiling fs_extra v1.3.0
[INFO] [stderr]    Compiling quote v1.0.36
[INFO] [stderr]    Compiling regex-automata v0.4.6
[INFO] [stderr]    Compiling regex v1.10.4
[INFO] [stderr]    Compiling env_logger v0.9.3
[INFO] [stderr]    Compiling lwext4-sys v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:79612
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...block))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inodes_count as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:79835
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_count_lo as * const _ as usize } , 4usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80064
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_blocks_count_lo as * const _ as usize } , 8...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_blocks_count_lo as * const _ as usize } , 12u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80551
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_inodes_count as * const _ as usize } , 16us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80785
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_data_block as * const _ as usize } , 20usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81017
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lock))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . log_block_size as * const _ as usize } , 24usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81245
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . log_cluster_size as * const _ as usize } , 28usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81477
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_per_group as * const _ as usize } , 32usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81709
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...roup))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . frags_per_group as * const _ as usize } , 36usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81939
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...oup))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inodes_per_group as * const _ as usize } , 40usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82171
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._group))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mount_time as * const _ as usize } , 44usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82391
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . write_time as * const _ as usize } , 48usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82611
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mount_count as * const _ as usize } , 52usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82833
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . max_mount_count as * const _ as usize } , 54usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83063
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt_count))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . magic as * const _ as usize } , 56usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83273
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (magic))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . state as * const _ as usize } , 58usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83483
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (state))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . errors as * const _ as usize } , 60usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83695
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rors))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . minor_rev_level as * const _ as usize } , 62usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...evel))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_check_time as * const _ as usize } , 64usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84155
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . check_interval as * const _ as usize } , 68usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84383
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...terval))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . creator_os as * const _ as usize } , 72usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84603
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ator_os))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . rev_level as * const _ as usize } , 76usize ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84821
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._level))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . def_resuid as * const _ as usize } , 80usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85041
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...resuid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . def_resgid as * const _ as usize } , 82usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85261
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...resgid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_inode as * const _ as usize } , 84usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85483
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inode_size as * const _ as usize } , 88usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85703
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . block_group_index as * const _ as usize } , 90us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85937
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ex))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_compatible as * const _ as usize } , 92u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:86175
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_incompatible as * const _ as usize } , 96...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:86417
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...le))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_read_only as * const _ as usize } , 100u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:87311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . algorithm_usage_bitmap as * const _ as usize } , 20...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88034
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . s_reserved_gdt_blocks as * const _ as usize } , 20...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88502
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...d))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_inode_number as * const _ as usize } , 224...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88743
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...number))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_dev as * const _ as usize } , 228usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88966
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...al_dev))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_orphan as * const _ as usize } , 232usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:89189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._orphan))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . hash_seed as * const _ as usize } , 236usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:89888
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...up_type))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . desc_size as * const _ as usize } , 254usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90107
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ze))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . default_mount_opts as * const _ as usize } , 256u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90344
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._opts))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_meta_bg as * const _ as usize } , 260usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90571
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...meta_bg))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mkfs_time as * const _ as usize } , 264usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90790
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_blocks as * const _ as usize } , 268usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91019
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ocks))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_count_hi as * const _ as usize } , 336us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91250
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_blocks_count_hi as * const _ as usize } , 3...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91499
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...i))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_blocks_count_hi as * const _ as usize } , 344...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91740
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . min_extra_isize as * const _ as usize } , 348us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91971
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . want_extra_isize as * const _ as usize } , 350us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92204
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tra_isize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . flags as * const _ as usize } , 352usize ,...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92415
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(flags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . raid_stride as * const _ as usize } , 356usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92638
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tride))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mmp_interval as * const _ as usize } , 358usiz...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92863
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nterval))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mmp_block as * const _ as usize } , 360usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:93082
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ock))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . raid_stripe_width as * const _ as usize } , 368u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:93783
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._type))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_pad as * const _ as usize } , 374usiz...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94008
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._pad))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . kbytes_written as * const _ as usize } , 376usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94237
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...itten))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_inum as * const _ as usize } , 384usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94464
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_inum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_id as * const _ as usize } , 388usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94687
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_r_blocks_count as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94934
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...count))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_list as * const _ as usize } , 400usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95161
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_list))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . error_count as * const _ as usize } , 404usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95384
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_time as * const _ as usize } , 408us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95617
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_ino as * const _ as usize } , 412us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95848
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_block as * const _ as usize } , 416u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96316
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unc))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_line as * const _ as usize } , 456us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96549
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...line))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_time as * const _ as usize } , 460us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96780
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_ino as * const _ as usize } , 464usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97009
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_line as * const _ as usize } , 468us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97240
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ine))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_block as * const _ as usize } , 472us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...opts))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . usr_quota_inum as * const _ as usize } , 576usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98154
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...inum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . grp_quota_inum as * const _ as usize } , 580usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98383
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...num))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . overhead_clusters as * const _ as usize } , 584u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98618
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...usters))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . backup_bgs as * const _ as usize } , 588usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99297
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._pw_salt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . lpf_ino as * const _ as usize } , 616usize ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(lpf_ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . padding as * const _ as usize } , 620usize ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99727
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...padding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . checksum as * const _ as usize } , 1020usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:107979
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . blocks_high as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108254
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . file_acl_high as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108533
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . uid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108802
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . gid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:109071
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . checksum_lo as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:109346
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . reserved2 as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110277
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . reserved1 as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110548
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . mode_high as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110819
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . uid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:111088
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . gid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:111357
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . author as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:112773
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ext4_inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . mode as * const _ as usize } , 0usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:112978
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...fy ! (mode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . uid as * const _ as usize } , 2usize , con...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113181
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (uid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . size_lo as * const _ as usize } , 4usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113392
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . access_time as * const _ as usize } , 8usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113611
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . change_inode_time as * const _ as usize } , 12usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113843
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . modification_time as * const _ as usize } , 16usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114075
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . deletion_time as * const _ as usize } , 20usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114299
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...etion_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . gid as * const _ as usize } , 24usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114503
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (gid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . links_count as * const _ as usize } , 26usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114723
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . blocks_count_lo as * const _ as usize } , 28usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114951
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._count_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . flags as * const _ as usize } , 32usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115159
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(flags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . unused_osd1 as * const _ as usize } , 36usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115379
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...used_osd1))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . blocks as * const _ as usize } , 40usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115589
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(blocks))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . generation as * const _ as usize } , 100usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115808
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ration))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . file_acl_lo as * const _ as usize } , 104usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116029
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_acl_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . size_hi as * const _ as usize } , 108usize ,...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116242
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...size_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . obso_faddr as * const _ as usize } , 112usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116668
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (osd2))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . extra_isize as * const _ as usize } , 128usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116889
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._isize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . checksum_hi as * const _ as usize } , 130usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117110
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sum_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . ctime_extra as * const _ as usize } , 132usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117331
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . mtime_extra as * const _ as usize } , 136usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117552
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . atime_extra as * const _ as usize } , 140usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117773
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime_extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . crtime as * const _ as usize } , 144usize ,...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117984
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...crtime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . crtime_extra as * const _ as usize } , 148usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:118207
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . version_hi as * const _ as usize } , 152usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:120535
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t4_dir_en))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_en > ())) . inode as * const _ as usize } , 0usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:120744
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_en > ())) . entry_len as * const _ as usize } , 4usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:122063
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...limit))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_climit > ())) . limit as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:122288
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...limit))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_climit > ())) . count as * const _ as usize } , 2usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:123068
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ot_en))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_dot_en > ())) . inode as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:123293
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_dot_en > ())) . entry_length as * const _ as usize } , 4us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:124784
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_rinfo > ())) . reserved_zero as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:126443
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._entry))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_entry > ())) . hash as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:126664
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(hash))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_entry > ())) . block as * const _ as usize } , 4usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:128606
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...entry))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_fake_dir_entry > ())) . inode as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:128831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_fake_dir_entry > ())) . entry_length as * const _ as usize } , 4us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:130953
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_tail > ())) . reserved as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:131180
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rved))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_tail > ())) . checksum as * const _ as usize } , 4usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:131964
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . reserved_zero1 as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:132207
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ero1))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . rec_len as * const _ as usize } , 4usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:132916
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._ft))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . checksum as * const _ as usize } , 8usiz...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133582
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (jbd_bhdr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . magic as * const _ as usize } , 0usize , con...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133785
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (magic))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . blocktype as * const _ as usize } , 4usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133996
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...blocktype))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . sequence as * const _ as usize } , 8usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:135727
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...dding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . chksum as * const _ as usize } , 16usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:135951
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . commit_sec as * const _ as usize } , 48usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:136183
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sec))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . commit_nsec as * const _ as usize } , 56us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:136911
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...k_tag3))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . blocknr as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137130
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...blocknr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . flags as * const _ as usize } , 4usize , ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137345
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . blocknr_high as * const _ as usize } , 8usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...r_high))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . checksum as * const _ as usize } , 12usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138284
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ock_tag))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . blocknr as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138501
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...locknr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . checksum as * const _ as usize } , 4usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138720
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...checksum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . flags as * const _ as usize } , 6usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138933
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . blocknr_high as * const _ as usize } , 8usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:139590
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...k_tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tail > ())) . checksum as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:140504
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...header))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_revoke_header > ())) . count as * const _ as usize } , 12usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:141162
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_revoke_tail > ())) . checksum as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142442
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (header))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . blocksize as * const _ as usize } , 12usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142650
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (blocksize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . maxlen as * const _ as usize } , 16usize , co...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142852
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (maxlen))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . first as * const _ as usize } , 20usize , con...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143052
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (first))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . sequence as * const _ as usize } , 24usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143258
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (sequence))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . start as * const _ as usize } , 28usize , con...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143458
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (start))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . error_val as * const _ as usize } , 32usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143666
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ror_val))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_compat as * const _ as usize } , 36usize ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143884
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...compat))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_incompat as * const _ as usize } , 40usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144106
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ompat))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_ro_compat as * const _ as usize } , 44usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144528
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...fy ! (uuid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . nr_users as * const _ as usize } , 64usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144734
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (nr_users))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . dynsuper as * const _ as usize } , 68usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144940
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nsuper))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . max_transaction as * const _ as usize } , 72usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:145160
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nsaction))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . max_trandata as * const _ as usize } , 76usize ,...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:145796
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (padding2))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . padding as * const _ as usize } , 84usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:146000
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (padding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . checksum as * const _ as usize } , 252usize , ...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 158 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0793`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `lwext4-sys` (lib test) due to 159 previous errors
[INFO] running `Command { std: "docker" "inspect" "55cd19915121354c452b68759f447f2ba277b2a8283baac50a636b0a9b5fd200", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "55cd19915121354c452b68759f447f2ba277b2a8283baac50a636b0a9b5fd200", kill_on_drop: false }`
[INFO] [stdout] 55cd19915121354c452b68759f447f2ba277b2a8283baac50a636b0a9b5fd200
[INFO] checking lwext4-sys-0.1.0 against try#9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88 for pr-124157
[INFO] extracting crate lwext4-sys 0.1.0 into /workspace/builds/worker-1-tc2/source
[INFO] validating manifest of crates.io crate lwext4-sys 0.1.0 on toolchain 9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate lwext4-sys 0.1.0
[INFO] finished tweaking crates.io crate lwext4-sys 0.1.0
[INFO] tweaked toml for crates.io crate lwext4-sys 0.1.0 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] [stderr]      Locking 60 packages to latest compatible versions
[INFO] [stderr]       Adding bindgen v0.59.2 (latest: v0.69.4)
[INFO] [stderr]       Adding bitflags v1.3.2 (latest: v2.5.0)
[INFO] [stderr]       Adding clap v2.34.0 (latest: v4.5.4)
[INFO] [stderr]       Adding env_logger v0.9.3 (latest: v0.11.3)
[INFO] [stderr]       Adding hermit-abi v0.1.19 (latest: v0.3.9)
[INFO] [stderr]       Adding linux-raw-sys v0.4.13 (latest: v0.6.4)
[INFO] [stderr]       Adding peeking_take_while v0.1.2 (latest: v1.0.0)
[INFO] [stderr]       Adding strsim v0.8.0 (latest: v0.11.1)
[INFO] [stderr]       Adding textwrap v0.11.0 (latest: v0.16.1)
[INFO] [stderr]       Adding which v4.4.2 (latest: v6.0.1)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] b5a76e587c44d289208f53f7c63870ec11c248d788e734793ab34dfea18d441d
[INFO] running `Command { std: "docker" "start" "-a" "b5a76e587c44d289208f53f7c63870ec11c248d788e734793ab34dfea18d441d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b5a76e587c44d289208f53f7c63870ec11c248d788e734793ab34dfea18d441d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b5a76e587c44d289208f53f7c63870ec11c248d788e734793ab34dfea18d441d", kill_on_drop: false }`
[INFO] [stdout] b5a76e587c44d289208f53f7c63870ec11c248d788e734793ab34dfea18d441d
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 041b2c407da98b13fc4e820c50a2120d1e2804f3bfe35f77a42e87ef1308ed58
[INFO] running `Command { std: "docker" "start" "-a" "041b2c407da98b13fc4e820c50a2120d1e2804f3bfe35f77a42e87ef1308ed58", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.81
[INFO] [stderr]    Compiling aho-corasick v1.1.3
[INFO] [stderr]    Compiling unicode-width v0.1.12
[INFO] [stderr]    Compiling atty v0.2.14
[INFO] [stderr]    Compiling ansi_term v0.12.1
[INFO] [stderr]    Compiling bitflags v1.3.2
[INFO] [stderr]    Compiling vec_map v0.8.2
[INFO] [stderr]    Compiling termcolor v1.4.1
[INFO] [stderr]    Compiling textwrap v0.11.0
[INFO] [stderr]    Compiling bindgen v0.59.2
[INFO] [stderr]    Compiling humantime v2.1.0
[INFO] [stderr]    Compiling strsim v0.8.0
[INFO] [stderr]    Compiling log v0.4.21
[INFO] [stderr]    Compiling make-cmd v0.1.0
[INFO] [stderr]    Compiling clap v2.34.0
[INFO] [stderr]    Compiling fs_extra v1.3.0
[INFO] [stderr]    Compiling quote v1.0.36
[INFO] [stderr]    Compiling regex-automata v0.4.6
[INFO] [stderr]    Compiling regex v1.10.4
[INFO] [stderr]    Compiling env_logger v0.9.3
[INFO] [stderr]    Compiling lwext4-sys v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:79612
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...block))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inodes_count as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:79835
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_count_lo as * const _ as usize } , 4usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80064
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_blocks_count_lo as * const _ as usize } , 8...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_blocks_count_lo as * const _ as usize } , 12u...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80551
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_inodes_count as * const _ as usize } , 16us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:80785
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_data_block as * const _ as usize } , 20usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81017
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lock))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . log_block_size as * const _ as usize } , 24usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81245
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . log_cluster_size as * const _ as usize } , 28usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81477
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_per_group as * const _ as usize } , 32usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81709
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...roup))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . frags_per_group as * const _ as usize } , 36usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:81939
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...oup))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inodes_per_group as * const _ as usize } , 40usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82171
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._group))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mount_time as * const _ as usize } , 44usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82391
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . write_time as * const _ as usize } , 48usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82611
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mount_count as * const _ as usize } , 52usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:82833
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . max_mount_count as * const _ as usize } , 54usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83063
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt_count))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . magic as * const _ as usize } , 56usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83273
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (magic))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . state as * const _ as usize } , 58usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83483
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (state))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . errors as * const _ as usize } , 60usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83695
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rors))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . minor_rev_level as * const _ as usize } , 62usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:83925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...evel))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_check_time as * const _ as usize } , 64usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84155
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . check_interval as * const _ as usize } , 68usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84383
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...terval))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . creator_os as * const _ as usize } , 72usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84603
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ator_os))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . rev_level as * const _ as usize } , 76usize ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:84821
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._level))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . def_resuid as * const _ as usize } , 80usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85041
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...resuid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . def_resgid as * const _ as usize } , 82usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85261
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...resgid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_inode as * const _ as usize } , 84usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85483
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . inode_size as * const _ as usize } , 88usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85703
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . block_group_index as * const _ as usize } , 90us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:85937
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ex))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_compatible as * const _ as usize } , 92u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:86175
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_incompatible as * const _ as usize } , 96...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:86417
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...le))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . features_read_only as * const _ as usize } , 100u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:87311
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . algorithm_usage_bitmap as * const _ as usize } , 20...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88034
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...s))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . s_reserved_gdt_blocks as * const _ as usize } , 20...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88502
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...d))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_inode_number as * const _ as usize } , 224...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88743
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...number))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_dev as * const _ as usize } , 228usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:88966
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...al_dev))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_orphan as * const _ as usize } , 232usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:89189
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._orphan))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . hash_seed as * const _ as usize } , 236usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:89888
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...up_type))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . desc_size as * const _ as usize } , 254usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90107
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ze))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . default_mount_opts as * const _ as usize } , 256u...
[INFO] [stdout]   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90344
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._opts))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_meta_bg as * const _ as usize } , 260usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90571
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...meta_bg))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mkfs_time as * const _ as usize } , 264usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:90790
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . journal_blocks as * const _ as usize } , 268usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91019
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ocks))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . blocks_count_hi as * const _ as usize } , 336us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91250
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...)) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_blocks_count_hi as * const _ as usize } , 3...
[INFO] [stdout]   |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91499
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...i))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . free_blocks_count_hi as * const _ as usize } , 344...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91740
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . min_extra_isize as * const _ as usize } , 348us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:91971
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . want_extra_isize as * const _ as usize } , 350us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92204
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tra_isize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . flags as * const _ as usize } , 352usize ,...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92415
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(flags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . raid_stride as * const _ as usize } , 356usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92638
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tride))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mmp_interval as * const _ as usize } , 358usiz...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:92863
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nterval))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . mmp_block as * const _ as usize } , 360usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:93082
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ock))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . raid_stripe_width as * const _ as usize } , 368u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:93783
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._type))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . reserved_pad as * const _ as usize } , 374usiz...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94008
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._pad))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . kbytes_written as * const _ as usize } , 376usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94237
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...itten))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_inum as * const _ as usize } , 384usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94464
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_inum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_id as * const _ as usize } , 388usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94687
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_r_blocks_count as * const _ as usize } , 3...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:94934
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...count))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . snapshot_list as * const _ as usize } , 400usi...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95161
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t_list))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . error_count as * const _ as usize } , 404usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95384
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_time as * const _ as usize } , 408us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95617
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_ino as * const _ as usize } , 412us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:95848
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_block as * const _ as usize } , 416u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96316
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...unc))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . first_error_line as * const _ as usize } , 456us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96549
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...line))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_time as * const _ as usize } , 460us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:96780
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_ino as * const _ as usize } , 464usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97009
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_line as * const _ as usize } , 468us...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97240
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ine))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . last_error_block as * const _ as usize } , 472us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:97925
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...opts))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . usr_quota_inum as * const _ as usize } , 576usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98154
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...inum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . grp_quota_inum as * const _ as usize } , 580usi...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98383
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...num))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . overhead_clusters as * const _ as usize } , 584u...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:98618
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...usters))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . backup_bgs as * const _ as usize } , 588usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99297
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._pw_salt))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . lpf_ino as * const _ as usize } , 616usize ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99512
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(lpf_ino))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . padding as * const _ as usize } , 620usize ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:99727
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...padding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_sblock > ())) . checksum as * const _ as usize } , 1020usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:107979
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . blocks_high as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108254
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . file_acl_high as * const _ as usi...
[INFO] [stdout]   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108533
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . uid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:108802
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . gid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:109071
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . checksum_lo as * const _ as usiz...
[INFO] [stdout]   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:109346
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_1 > ())) . reserved2 as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110277
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . reserved1 as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110548
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ssert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . mode_high as * const _ as usize...
[INFO] [stdout]   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:110819
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . uid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:111088
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . gid_high as * const _ as usize...
[INFO] [stdout]   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:111357
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode__bindgen_ty_1__bindgen_ty_2 > ())) . author as * const _ as usize ...
[INFO] [stdout]   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:112773
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ext4_inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . mode as * const _ as usize } , 0usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:112978
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...fy ! (mode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . uid as * const _ as usize } , 2usize , con...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113181
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (uid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . size_lo as * const _ as usize } , 4usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113392
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ize_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . access_time as * const _ as usize } , 8usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113611
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . change_inode_time as * const _ as usize } , 12usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:113843
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . modification_time as * const _ as usize } , 16usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114075
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . deletion_time as * const _ as usize } , 20usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114299
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...etion_time))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . gid as * const _ as usize } , 24usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114503
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (gid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . links_count as * const _ as usize } , 26usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114723
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ount))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . blocks_count_lo as * const _ as usize } , 28usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:114951
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._count_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . flags as * const _ as usize } , 32usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115159
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(flags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . unused_osd1 as * const _ as usize } , 36usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115379
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...used_osd1))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . blocks as * const _ as usize } , 40usize , ...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115589
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(blocks))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . generation as * const _ as usize } , 100usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:115808
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ration))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . file_acl_lo as * const _ as usize } , 104usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116029
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_acl_lo))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . size_hi as * const _ as usize } , 108usize ,...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116242
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...size_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . obso_faddr as * const _ as usize } , 112usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116668
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (osd2))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . extra_isize as * const _ as usize } , 128usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:116889
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._isize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . checksum_hi as * const _ as usize } , 130usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117110
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sum_hi))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . ctime_extra as * const _ as usize } , 132usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117331
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . mtime_extra as * const _ as usize } , 136usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117552
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . atime_extra as * const _ as usize } , 140usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117773
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ime_extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . crtime as * const _ as usize } , 144usize ,...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:117984
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...crtime))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . crtime_extra as * const _ as usize } , 148usiz...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:118207
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e_extra))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_inode > ())) . version_hi as * const _ as usize } , 152usize...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:120535
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...t4_dir_en))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_en > ())) . inode as * const _ as usize } , 0usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:120744
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (inode))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_en > ())) . entry_len as * const _ as usize } , 4usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:122063
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...limit))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_climit > ())) . limit as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:122288
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...limit))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_climit > ())) . count as * const _ as usize } , 2usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:123068
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ot_en))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_dot_en > ())) . inode as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:123293
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_dot_en > ())) . entry_length as * const _ as usize } , 4us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:124784
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...o))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_rinfo > ())) . reserved_zero as * const _ as usize } , 0us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:126443
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._entry))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_entry > ())) . hash as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:126664
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...(hash))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_entry > ())) . block as * const _ as usize } , 4usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:128606
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...entry))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_fake_dir_entry > ())) . inode as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:128831
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...e))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_fake_dir_entry > ())) . entry_length as * const _ as usize } , 4us...
[INFO] [stdout]   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:130953
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_tail > ())) . reserved as * const _ as usize } , 0usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:131180
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...rved))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_idx_tail > ())) . checksum as * const _ as usize } , 4usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:131964
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . reserved_zero1 as * const _ as usize } , 0u...
[INFO] [stdout]   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:132207
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ero1))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . rec_len as * const _ as usize } , 4usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:132916
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._ft))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < ext4_dir_entry_tail > ())) . checksum as * const _ as usize } , 8usiz...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133582
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (jbd_bhdr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . magic as * const _ as usize } , 0usize , con...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133785
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (magic))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . blocktype as * const _ as usize } , 4usize , c...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:133996
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...blocktype))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_bhdr > ())) . sequence as * const _ as usize } , 8usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:135727
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...dding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . chksum as * const _ as usize } , 16usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:135951
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . commit_sec as * const _ as usize } , 48usi...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:136183
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...sec))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_commit_header > ())) . commit_nsec as * const _ as usize } , 56us...
[INFO] [stdout]   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:136911
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...k_tag3))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . blocknr as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137130
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...blocknr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . flags as * const _ as usize } , 4usize , ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137345
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . blocknr_high as * const _ as usize } , 8usiz...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:137574
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...r_high))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag3 > ())) . checksum as * const _ as usize } , 12usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138284
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ock_tag))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . blocknr as * const _ as usize } , 0usize ,...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138501
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...locknr))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . checksum as * const _ as usize } , 4usize ,...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138720
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...checksum))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . flags as * const _ as usize } , 6usize , ...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:138933
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...lags))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tag > ())) . blocknr_high as * const _ as usize } , 8usize...
[INFO] [stdout]   |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:139590
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...k_tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_block_tail > ())) . checksum as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:140504
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...header))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_revoke_header > ())) . count as * const _ as usize } , 12usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:141162
[INFO] [stdout]   |
[INFO] [stdout] 3 | ..._tail))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_revoke_tail > ())) . checksum as * const _ as usize } , 0usize ...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142442
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (header))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . blocksize as * const _ as usize } , 12usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142650
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (blocksize))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . maxlen as * const _ as usize } , 16usize , co...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:142852
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (maxlen))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . first as * const _ as usize } , 20usize , con...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143052
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...y ! (first))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . sequence as * const _ as usize } , 24usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143258
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (sequence))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . start as * const _ as usize } , 28usize , con...
[INFO] [stdout]   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143458
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... ! (start))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . error_val as * const _ as usize } , 32usize , c...
[INFO] [stdout]   |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143666
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ror_val))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_compat as * const _ as usize } , 36usize ...
[INFO] [stdout]   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:143884
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...compat))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_incompat as * const _ as usize } , 40usize...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144106
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...ompat))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . feature_ro_compat as * const _ as usize } , 44usize...
[INFO] [stdout]   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144528
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...fy ! (uuid))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . nr_users as * const _ as usize } , 64usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144734
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (nr_users))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . dynsuper as * const _ as usize } , 68usize , c...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:144940
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nsuper))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . max_transaction as * const _ as usize } , 72usize ...
[INFO] [stdout]   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:145160
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...nsaction))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . max_trandata as * const _ as usize } , 76usize ,...
[INFO] [stdout]   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:145796
[INFO] [stdout]   |
[INFO] [stdout] 3 | ... (padding2))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . padding as * const _ as usize } , 84usize , co...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]  --> /opt/rustwide/target/debug/build/lwext4-sys-dc07ea0584e0e89c/out/ext4.rs:3:146000
[INFO] [stdout]   |
[INFO] [stdout] 3 | ...! (padding))) ; assert_eq ! (unsafe { & (* (:: core :: ptr :: null :: < jbd_sb > ())) . checksum as * const _ as usize } , 252usize , ...
[INFO] [stdout]   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]   |
[INFO] [stdout]   = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]   = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]   = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 158 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0793`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `lwext4-sys` (lib test) due to 159 previous errors
[INFO] running `Command { std: "docker" "inspect" "041b2c407da98b13fc4e820c50a2120d1e2804f3bfe35f77a42e87ef1308ed58", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "041b2c407da98b13fc4e820c50a2120d1e2804f3bfe35f77a42e87ef1308ed58", kill_on_drop: false }`
[INFO] [stdout] 041b2c407da98b13fc4e820c50a2120d1e2804f3bfe35f77a42e87ef1308ed58
