forked from M-Labs/zynq-rs
add libconfig, libcoreio, szl from artiq-zynq a277e89b3ad; update dependencies
This commit is contained in:
parent
82794d3abd
commit
7360984efb
|
|
@ -2,7 +2,7 @@
|
||||||
# It is not intended for manual editing.
|
# It is not intended for manual editing.
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "bit_field"
|
name = "bit_field"
|
||||||
version = "0.10.0"
|
version = "0.10.1"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -22,15 +22,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "compiler_builtins"
|
name = "compiler_builtins"
|
||||||
version = "0.1.32"
|
version = "0.1.35"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "core_io"
|
||||||
|
version = "0.1.20200410"
|
||||||
|
dependencies = [
|
||||||
|
"memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "embedded-hal"
|
name = "embedded-hal"
|
||||||
version = "0.2.3"
|
version = "0.2.4"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"nb 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"nb 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
|
@ -38,22 +45,33 @@ dependencies = [
|
||||||
name = "experiments"
|
name = "experiments"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"embedded-hal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
"embedded-hal 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"libasync 0.0.0",
|
"libasync 0.0.0",
|
||||||
"libboard_zynq 0.0.0",
|
"libboard_zynq 0.0.0",
|
||||||
"libcortex_a9 0.0.0",
|
"libcortex_a9 0.0.0",
|
||||||
"libregister 0.0.0",
|
"libregister 0.0.0",
|
||||||
"libsupport_zynq 0.0.0",
|
"libsupport_zynq 0.0.0",
|
||||||
"log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "fatfs"
|
||||||
|
version = "0.3.4"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
dependencies = [
|
||||||
|
"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
"core_io 0.1.20200410",
|
||||||
|
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "libasync"
|
name = "libasync"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"embedded-hal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
"embedded-hal 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"libcortex_a9 0.0.0",
|
"libcortex_a9 0.0.0",
|
||||||
"nb 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"nb 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
@ -62,22 +80,32 @@ dependencies = [
|
||||||
name = "libboard_zynq"
|
name = "libboard_zynq"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bit_field 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"bit_field 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"embedded-hal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
"embedded-hal 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"libcortex_a9 0.0.0",
|
"libcortex_a9 0.0.0",
|
||||||
"libregister 0.0.0",
|
"libregister 0.0.0",
|
||||||
"log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
|
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"nb 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"nb 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "libconfig"
|
||||||
|
version = "0.1.0"
|
||||||
|
dependencies = [
|
||||||
|
"core_io 0.1.20200410",
|
||||||
|
"fatfs 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
"libboard_zynq 0.0.0",
|
||||||
|
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "libcortex_a9"
|
name = "libcortex_a9"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bit_field 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"bit_field 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"libregister 0.0.0",
|
"libregister 0.0.0",
|
||||||
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
@ -86,7 +114,7 @@ dependencies = [
|
||||||
name = "libregister"
|
name = "libregister"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bit_field 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"bit_field 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"vcell 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
"vcell 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"volatile-register 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
@ -95,22 +123,22 @@ dependencies = [
|
||||||
name = "libsupport_zynq"
|
name = "libsupport_zynq"
|
||||||
version = "0.0.0"
|
version = "0.0.0"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"compiler_builtins 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)",
|
"compiler_builtins 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"libboard_zynq 0.0.0",
|
"libboard_zynq 0.0.0",
|
||||||
"libcortex_a9 0.0.0",
|
"libcortex_a9 0.0.0",
|
||||||
"libregister 0.0.0",
|
"libregister 0.0.0",
|
||||||
"linked_list_allocator 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
"linked_list_allocator 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"r0 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
"r0 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "linked_list_allocator"
|
name = "linked_list_allocator"
|
||||||
version = "0.8.4"
|
version = "0.8.5"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "log"
|
name = "log"
|
||||||
version = "0.4.8"
|
version = "0.4.11"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
|
"cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
|
@ -118,12 +146,25 @@ dependencies = [
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "managed"
|
name = "managed"
|
||||||
version = "0.7.1"
|
version = "0.7.2"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "memchr"
|
||||||
|
version = "2.3.3"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "nb"
|
name = "nb"
|
||||||
version = "0.1.2"
|
version = "0.1.3"
|
||||||
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
dependencies = [
|
||||||
|
"nb 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "nb"
|
||||||
|
version = "1.0.0"
|
||||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -143,7 +184,21 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
"bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
"managed 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
|
"managed 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "szl"
|
||||||
|
version = "0.1.0"
|
||||||
|
dependencies = [
|
||||||
|
"byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
|
"core_io 0.1.20200410",
|
||||||
|
"libboard_zynq 0.0.0",
|
||||||
|
"libconfig 0.1.0",
|
||||||
|
"libcortex_a9 0.0.0",
|
||||||
|
"libregister 0.0.0",
|
||||||
|
"libsupport_zynq 0.0.0",
|
||||||
|
"log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)",
|
||||||
]
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
|
|
@ -165,16 +220,19 @@ dependencies = [
|
||||||
]
|
]
|
||||||
|
|
||||||
[metadata]
|
[metadata]
|
||||||
"checksum bit_field 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a165d606cf084741d4ac3a28fb6e9b1eb0bd31f6cd999098cfddb0b2ab381dc0"
|
"checksum bit_field 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
|
||||||
"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
|
"checksum bitflags 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
|
||||||
"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
|
"checksum byteorder 1.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "08c48aae112d48ed9f069b33538ea9e3e90aa263cfa3d1c24309612b1f7472de"
|
||||||
"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
|
"checksum cfg-if 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)" = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
|
||||||
"checksum compiler_builtins 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "7bc4ac2c824d2bfc612cba57708198547e9a26943af0632aff033e0693074d5c"
|
"checksum compiler_builtins 0.1.35 (registry+https://github.com/rust-lang/crates.io-index)" = "e3fcd8aba10d17504c87ef12d4f62ef404c6a4703d16682a9eb5543e6cf24455"
|
||||||
"checksum embedded-hal 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "ee4908a155094da7723c2d60d617b820061e3b4efcc3d9e293d206a5a76c170b"
|
"checksum embedded-hal 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "fa998ce59ec9765d15216393af37a58961ddcefb14c753b4816ba2191d865fcb"
|
||||||
"checksum linked_list_allocator 0.8.4 (registry+https://github.com/rust-lang/crates.io-index)" = "e70e46c13c0e8374c26cec5752e3347ca1087d9711de8f45aa513a7700efd73d"
|
"checksum fatfs 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "93079df23039e52059e1f03b4c29fb0c72da2c792aad91bb2236c9fb81d3592e"
|
||||||
"checksum log 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)" = "14b6052be84e6b71ab17edffc2eeabf5c2c3ae1fdb464aae35ac50c67a44e1f7"
|
"checksum linked_list_allocator 0.8.5 (registry+https://github.com/rust-lang/crates.io-index)" = "660b26e6156a7d00eefb19052fe1943cf5ab2f353a723a577fad6ba2f99d1f90"
|
||||||
"checksum managed 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fdcec5e97041c7f0f1c5b7d93f12e57293c831c646f4cc7a5db59460c7ea8de6"
|
"checksum log 0.4.11 (registry+https://github.com/rust-lang/crates.io-index)" = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b"
|
||||||
"checksum nb 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b1411551beb3c11dedfb0a90a0fa256b47d28b9ec2cdff34c25a2fa59e45dbdc"
|
"checksum managed 0.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "c75de51135344a4f8ed3cfe2720dc27736f7711989703a0b43aadf3753c55577"
|
||||||
|
"checksum memchr 2.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
|
||||||
|
"checksum nb 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
|
||||||
|
"checksum nb 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
|
||||||
"checksum pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
|
"checksum pin-utils 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
|
||||||
"checksum r0 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd7a31eed1591dcbc95d92ad7161908e72f4677f8fabf2a32ca49b4237cbf211"
|
"checksum r0 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd7a31eed1591dcbc95d92ad7161908e72f4677f8fabf2a32ca49b4237cbf211"
|
||||||
"checksum smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0fe46639fd2ec79eadf8fe719f237a7a0bd4dac5d957f1ca5bbdbc1c3c39e53a"
|
"checksum smoltcp 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0fe46639fd2ec79eadf8fe719f237a7a0bd4dac5d957f1ca5bbdbc1c3c39e53a"
|
||||||
|
|
|
||||||
19
Cargo.toml
19
Cargo.toml
|
|
@ -1,15 +1,24 @@
|
||||||
[workspace]
|
[workspace]
|
||||||
members = [
|
members = [
|
||||||
"libregister", "libcortex_a9",
|
"libregister",
|
||||||
"libboard_zynq", "libsupport_zynq",
|
"libcortex_a9",
|
||||||
|
"libboard_zynq",
|
||||||
|
"libsupport_zynq",
|
||||||
"libasync",
|
"libasync",
|
||||||
|
"libconfig",
|
||||||
|
"libcoreio",
|
||||||
"experiments",
|
"experiments",
|
||||||
|
"szl",
|
||||||
]
|
]
|
||||||
|
|
||||||
[profile.release]
|
[profile.release]
|
||||||
panic = "abort"
|
panic = "abort"
|
||||||
debug = true
|
debug = true
|
||||||
# Link-Time Optimization:
|
codegen-units = 1
|
||||||
# turn off if you get unusable debug symbols.
|
opt-level = 'z'
|
||||||
lto = true
|
lto = true
|
||||||
opt-level = 'z' # Optimize for size.
|
debug-assertions = false
|
||||||
|
overflow-checks = false
|
||||||
|
|
||||||
|
[patch.crates-io]
|
||||||
|
core_io = { path = "./libcoreio" }
|
||||||
|
|
|
||||||
|
|
@ -6,7 +6,7 @@ let
|
||||||
name = "${crate}";
|
name = "${crate}";
|
||||||
|
|
||||||
src = ./.;
|
src = ./.;
|
||||||
cargoSha256 = "1gdxrsn58mabqf8yc3xqkrl1qlmlyvpnzcfj4xafpdr1gdhwhdjg";
|
cargoSha256 = "1f2psa1g41pl2j8n60hhik2s2pqdfjhr5capimvajf81kxrnn2ck";
|
||||||
|
|
||||||
nativeBuildInputs = [ pkgs.cargo-xbuild ];
|
nativeBuildInputs = [ pkgs.cargo-xbuild ];
|
||||||
buildPhase = ''
|
buildPhase = ''
|
||||||
|
|
@ -33,4 +33,5 @@ in
|
||||||
zc706-experiments = build-crate "zc706-experiments" "experiments" "target_zc706";
|
zc706-experiments = build-crate "zc706-experiments" "experiments" "target_zc706";
|
||||||
cora-experiments = build-crate "cora-experiments" "experiments" "target_cora_z7_10";
|
cora-experiments = build-crate "cora-experiments" "experiments" "target_cora_z7_10";
|
||||||
zc706-fsbl = (import ./nix/fsbl.nix { inherit pkgs; });
|
zc706-fsbl = (import ./nix/fsbl.nix { inherit pkgs; });
|
||||||
|
zc706-szl = build-crate "zc706-szl" "szl" "target_zc706";
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,15 @@
|
||||||
|
[package]
|
||||||
|
name = "libconfig"
|
||||||
|
version = "0.1.0"
|
||||||
|
authors = ["M-Labs"]
|
||||||
|
edition = "2018"
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
libboard_zynq = { path = "../libboard_zynq" }
|
||||||
|
core_io = { version = "0.1", features = ["collections"] }
|
||||||
|
fatfs = { version = "0.3", features = ["core_io"], default-features = false }
|
||||||
|
log = "0.4"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
ipv6 = []
|
||||||
|
|
||||||
|
|
@ -0,0 +1,181 @@
|
||||||
|
use alloc::vec::Vec;
|
||||||
|
use core_io::{Error, Read, Seek, SeekFrom};
|
||||||
|
use libboard_zynq::devc;
|
||||||
|
use log::debug;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum BootgenLoadingError {
|
||||||
|
InvalidBootImageHeader,
|
||||||
|
MissingPartition,
|
||||||
|
EncryptedBitstream,
|
||||||
|
IoError(Error),
|
||||||
|
DevcError(devc::DevcError),
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<Error> for BootgenLoadingError {
|
||||||
|
fn from(error: Error) -> Self {
|
||||||
|
BootgenLoadingError::IoError(error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl From<devc::DevcError> for BootgenLoadingError {
|
||||||
|
fn from(error: devc::DevcError) -> Self {
|
||||||
|
BootgenLoadingError::DevcError(error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl core::fmt::Display for BootgenLoadingError {
|
||||||
|
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
|
||||||
|
use BootgenLoadingError::*;
|
||||||
|
match self {
|
||||||
|
InvalidBootImageHeader => write!(
|
||||||
|
f,
|
||||||
|
"Invalid boot image header. Check if the file is correct."
|
||||||
|
),
|
||||||
|
MissingPartition => write!(f, "Partition not found. Check your compile configuration."),
|
||||||
|
EncryptedBitstream => write!(f, "Encrypted bitstream is not supported."),
|
||||||
|
IoError(e) => write!(f, "Error while reading: {}", e),
|
||||||
|
DevcError(e) => write!(f, "PCAP interface error: {}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(C)]
|
||||||
|
struct PartitionHeader {
|
||||||
|
pub encrypted_length: u32,
|
||||||
|
pub unencrypted_length: u32,
|
||||||
|
pub word_length: u32,
|
||||||
|
pub dest_load_addr: u32,
|
||||||
|
pub dest_exec_addr: u32,
|
||||||
|
pub data_offset: u32,
|
||||||
|
pub attribute_bits: u32,
|
||||||
|
pub section_count: u32,
|
||||||
|
pub checksum_offset: u32,
|
||||||
|
pub header_offset: u32,
|
||||||
|
pub cert_offset: u32,
|
||||||
|
pub reserved: [u32; 4],
|
||||||
|
pub checksum: u32,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read a u32 word from the reader.
|
||||||
|
fn read_u32<Reader: Read>(reader: &mut Reader) -> Result<u32, BootgenLoadingError> {
|
||||||
|
let mut buffer: [u8; 4] = [0; 4];
|
||||||
|
reader.read_exact(&mut buffer)?;
|
||||||
|
let mut result: u32 = 0;
|
||||||
|
for i in 0..4 {
|
||||||
|
result |= (buffer[i] as u32) << (i * 8);
|
||||||
|
}
|
||||||
|
Ok(result)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Load PL partition header.
|
||||||
|
fn load_pl_header<File: Read + Seek>(
|
||||||
|
file: &mut File,
|
||||||
|
) -> Result<Option<PartitionHeader>, BootgenLoadingError> {
|
||||||
|
let mut buffer: [u8; 0x40] = [0; 0x40];
|
||||||
|
file.read_exact(&mut buffer)?;
|
||||||
|
let header = unsafe { core::mem::transmute::<_, PartitionHeader>(buffer) };
|
||||||
|
if header.attribute_bits & (2 << 4) != 0 {
|
||||||
|
Ok(Some(header))
|
||||||
|
} else {
|
||||||
|
Ok(None)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn load_ps_header<File: Read + Seek>(
|
||||||
|
file: &mut File,
|
||||||
|
) -> Result<Option<PartitionHeader>, BootgenLoadingError> {
|
||||||
|
let mut buffer: [u8; 0x40] = [0; 0x40];
|
||||||
|
file.read_exact(&mut buffer)?;
|
||||||
|
let header = unsafe { core::mem::transmute::<_, PartitionHeader>(buffer) };
|
||||||
|
if header.attribute_bits & (1 << 4) != 0 {
|
||||||
|
Ok(Some(header))
|
||||||
|
} else {
|
||||||
|
Ok(None)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Locate the partition from the image, and return the size (in bytes) of the partition if successful.
|
||||||
|
/// This function would seek the file to the location of the partition.
|
||||||
|
fn locate<
|
||||||
|
File: Read + Seek,
|
||||||
|
F: Fn(&mut File) -> Result<Option<PartitionHeader>, BootgenLoadingError>,
|
||||||
|
>(
|
||||||
|
file: &mut File,
|
||||||
|
f: F,
|
||||||
|
) -> Result<usize, BootgenLoadingError> {
|
||||||
|
file.seek(SeekFrom::Start(0))?;
|
||||||
|
const BOOT_HEADER_SIGN: u32 = 0x584C4E58;
|
||||||
|
// read boot header signature
|
||||||
|
file.seek(SeekFrom::Start(0x24))?;
|
||||||
|
if read_u32(file)? != BOOT_HEADER_SIGN {
|
||||||
|
return Err(BootgenLoadingError::InvalidBootImageHeader);
|
||||||
|
}
|
||||||
|
// find fsbl offset
|
||||||
|
file.seek(SeekFrom::Start(0x30))?;
|
||||||
|
// the length is in bytes, we have to convert it to words to compare with the partition offset
|
||||||
|
// later
|
||||||
|
let fsbl = read_u32(file)? / 4;
|
||||||
|
// read partition header offset
|
||||||
|
file.seek(SeekFrom::Start(0x9C))?;
|
||||||
|
let ptr = read_u32(file)?;
|
||||||
|
debug!("Partition header pointer = {:0X}", ptr);
|
||||||
|
file.seek(SeekFrom::Start(ptr as u64))?;
|
||||||
|
|
||||||
|
// at most 3 partition headers
|
||||||
|
for _ in 0..3 {
|
||||||
|
if let Some(header) = f(file)? {
|
||||||
|
let encrypted_length = header.encrypted_length;
|
||||||
|
let unencrypted_length = header.unencrypted_length;
|
||||||
|
debug!("Unencrypted length = {:0X}", unencrypted_length);
|
||||||
|
if encrypted_length != unencrypted_length {
|
||||||
|
return Err(BootgenLoadingError::EncryptedBitstream);
|
||||||
|
}
|
||||||
|
|
||||||
|
let start_addr = header.data_offset;
|
||||||
|
// skip fsbl
|
||||||
|
if start_addr == fsbl {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
debug!("Partition start address: {:0X}", start_addr);
|
||||||
|
file.seek(SeekFrom::Start(start_addr as u64 * 4))?;
|
||||||
|
|
||||||
|
return Ok(unencrypted_length as usize * 4);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Err(BootgenLoadingError::MissingPartition)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Load bitstream from bootgen file.
|
||||||
|
/// This function parses the file, locate the bitstream and load it through the PCAP driver.
|
||||||
|
/// It requires a large buffer, please enable the DDR RAM before using it.
|
||||||
|
pub fn load_bitstream<File: Read + Seek>(file: &mut File) -> Result<(), BootgenLoadingError> {
|
||||||
|
let size = locate(file, load_pl_header)?;
|
||||||
|
unsafe {
|
||||||
|
// align to 64 bytes
|
||||||
|
let ptr = alloc::alloc::alloc(alloc::alloc::Layout::from_size_align(size, 64).unwrap());
|
||||||
|
let buffer = core::slice::from_raw_parts_mut(ptr, size);
|
||||||
|
file.read_exact(buffer).map_err(|e| {
|
||||||
|
core::ptr::drop_in_place(ptr);
|
||||||
|
e
|
||||||
|
})?;
|
||||||
|
let mut devcfg = devc::DevC::new();
|
||||||
|
devcfg.enable();
|
||||||
|
devcfg.program(&buffer).map_err(|e| {
|
||||||
|
core::ptr::drop_in_place(ptr);
|
||||||
|
e
|
||||||
|
})?;
|
||||||
|
core::ptr::drop_in_place(ptr);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_runtime<File: Read + Seek>(file: &mut File) -> Result<Vec<u8>, BootgenLoadingError> {
|
||||||
|
let size = locate(file, load_ps_header)?;
|
||||||
|
let mut buffer = Vec::with_capacity(size);
|
||||||
|
unsafe {
|
||||||
|
buffer.set_len(size);
|
||||||
|
}
|
||||||
|
file.read_exact(&mut buffer)?;
|
||||||
|
Ok(buffer)
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,115 @@
|
||||||
|
#![no_std]
|
||||||
|
extern crate alloc;
|
||||||
|
|
||||||
|
use core::fmt;
|
||||||
|
use alloc::{string::FromUtf8Error, string::String, vec::Vec, rc::Rc};
|
||||||
|
use core_io::{self as io, BufRead, BufReader, Read};
|
||||||
|
use libboard_zynq::sdio;
|
||||||
|
|
||||||
|
pub mod sd_reader;
|
||||||
|
pub mod net_settings;
|
||||||
|
pub mod bootgen;
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum Error<'a> {
|
||||||
|
SdError(sdio::sd_card::CardInitializationError),
|
||||||
|
IoError(io::Error),
|
||||||
|
Utf8Error(FromUtf8Error),
|
||||||
|
KeyNotFoundError(&'a str),
|
||||||
|
NoConfig,
|
||||||
|
}
|
||||||
|
|
||||||
|
pub type Result<'a, T> = core::result::Result<T, Error<'a>>;
|
||||||
|
|
||||||
|
impl<'a> fmt::Display for Error<'a> {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
match self {
|
||||||
|
Error::SdError(error) => write!(f, "SD error: {}", error),
|
||||||
|
Error::IoError(error) => write!(f, "I/O error: {}", error),
|
||||||
|
Error::Utf8Error(error) => write!(f, "UTF-8 error: {}", error),
|
||||||
|
Error::KeyNotFoundError(name) => write!(f, "Configuration key `{}` not found", name),
|
||||||
|
Error::NoConfig => write!(f, "Configuration not present"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> From<sdio::sd_card::CardInitializationError> for Error<'a> {
|
||||||
|
fn from(error: sdio::sd_card::CardInitializationError) -> Self {
|
||||||
|
Error::SdError(error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> From<io::Error> for Error<'a> {
|
||||||
|
fn from(error: io::Error) -> Self {
|
||||||
|
Error::IoError(error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<'a> From<FromUtf8Error> for Error<'a> {
|
||||||
|
fn from(error: FromUtf8Error) -> Self {
|
||||||
|
Error::Utf8Error(error)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_config<'a>(
|
||||||
|
key: &'a str,
|
||||||
|
buffer: &mut Vec<u8>,
|
||||||
|
file: fatfs::File<sd_reader::SdReader>,
|
||||||
|
) -> Result<'a, ()> {
|
||||||
|
let prefix = [key, "="].concat();
|
||||||
|
for line in BufReader::new(file).lines() {
|
||||||
|
let line = line?;
|
||||||
|
if line.starts_with(&prefix) {
|
||||||
|
buffer.extend(line[prefix.len()..].as_bytes());
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Err(Error::KeyNotFoundError(key))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub struct Config {
|
||||||
|
fs: Option<Rc<fatfs::FileSystem<sd_reader::SdReader>>>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Config {
|
||||||
|
pub fn new() -> Result<'static, Self> {
|
||||||
|
let sdio = sdio::Sdio::sdio0(true);
|
||||||
|
if !sdio.is_card_inserted() {
|
||||||
|
Err(sdio::sd_card::CardInitializationError::NoCardInserted)?;
|
||||||
|
}
|
||||||
|
let sd = sdio::sd_card::SdCard::from_sdio(sdio)?;
|
||||||
|
let reader = sd_reader::SdReader::new(sd);
|
||||||
|
|
||||||
|
let fs = reader.mount_fatfs(sd_reader::PartitionEntry::Entry1)?;
|
||||||
|
Ok(Config { fs: Some(Rc::new(fs)) })
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn from_fs(fs: Option<Rc<fatfs::FileSystem<sd_reader::SdReader>>>) -> Self {
|
||||||
|
Config { fs }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn new_dummy() -> Self {
|
||||||
|
Config { fs: None }
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn read<'b>(&self, key: &'b str) -> Result<'b, Vec<u8>> {
|
||||||
|
if let Some(fs) = &self.fs {
|
||||||
|
let root_dir = fs.root_dir();
|
||||||
|
let mut buffer: Vec<u8> = Vec::new();
|
||||||
|
match root_dir.open_file(&["/CONFIG/", key, ".BIN"].concat()) {
|
||||||
|
Ok(mut f) => f.read_to_end(&mut buffer).map(|_| ())?,
|
||||||
|
Err(_) => match root_dir.open_file("/CONFIG.TXT") {
|
||||||
|
Ok(f) => parse_config(key, &mut buffer, f)?,
|
||||||
|
Err(_) => return Err(Error::KeyNotFoundError(key)),
|
||||||
|
},
|
||||||
|
};
|
||||||
|
Ok(buffer)
|
||||||
|
} else {
|
||||||
|
Err(Error::NoConfig)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn read_str<'b>(&self, key: &'b str) -> Result<'b, String> {
|
||||||
|
Ok(String::from_utf8(self.read(key)?)?)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,62 @@
|
||||||
|
use core::fmt;
|
||||||
|
|
||||||
|
use libboard_zynq::smoltcp::wire::{EthernetAddress, IpAddress};
|
||||||
|
|
||||||
|
use super::Config;
|
||||||
|
|
||||||
|
pub struct NetAddresses {
|
||||||
|
pub hardware_addr: EthernetAddress,
|
||||||
|
pub ipv4_addr: IpAddress,
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
pub ipv6_ll_addr: IpAddress,
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
pub ipv6_addr: Option<IpAddress>
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for NetAddresses {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||||
|
write!(f, "MAC={} IPv4={} ",
|
||||||
|
self.hardware_addr, self.ipv4_addr)?;
|
||||||
|
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
{
|
||||||
|
write!(f, "IPv6-LL={}", self.ipv6_ll_addr)?;
|
||||||
|
match self.ipv6_addr {
|
||||||
|
Some(addr) => write!(f, " {}", addr)?,
|
||||||
|
None => write!(f, " IPv6: no configured address")?
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn get_adresses(cfg: &Config) -> NetAddresses {
|
||||||
|
let mut hardware_addr = EthernetAddress([0x02, 0x00, 0x00, 0x00, 0x00, 0x52]);
|
||||||
|
let mut ipv4_addr = IpAddress::v4(192, 168, 1, 52);
|
||||||
|
|
||||||
|
if let Ok(Ok(addr)) = cfg.read_str("mac").map(|s| s.parse()) {
|
||||||
|
hardware_addr = addr;
|
||||||
|
}
|
||||||
|
if let Ok(Ok(addr)) = cfg.read_str("ip").map(|s| s.parse()) {
|
||||||
|
ipv4_addr = addr;
|
||||||
|
}
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
let ipv6_addr = cfg.read_str("ipv6").ok().and_then(|s| s.parse().ok());
|
||||||
|
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
let ipv6_ll_addr = IpAddress::v6(
|
||||||
|
0xfe80, 0x0000, 0x0000, 0x0000,
|
||||||
|
(((hardware_addr.0[0] ^ 0x02) as u16) << 8) | (hardware_addr.0[1] as u16),
|
||||||
|
((hardware_addr.0[2] as u16) << 8) | 0x00ff,
|
||||||
|
0xfe00 | (hardware_addr.0[3] as u16),
|
||||||
|
((hardware_addr.0[4] as u16) << 8) | (hardware_addr.0[5] as u16));
|
||||||
|
|
||||||
|
NetAddresses {
|
||||||
|
hardware_addr,
|
||||||
|
ipv4_addr,
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
ipv6_ll_addr,
|
||||||
|
#[cfg(feature = "ipv6")]
|
||||||
|
ipv6_addr
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,303 @@
|
||||||
|
use core_io::{BufRead, Error, ErrorKind, Read, Result as IoResult, Seek, SeekFrom, Write};
|
||||||
|
use fatfs;
|
||||||
|
use libboard_zynq::sdio::{sd_card::SdCard, CmdTransferError};
|
||||||
|
use log::debug;
|
||||||
|
use alloc::vec::Vec;
|
||||||
|
|
||||||
|
const MBR_SIGNATURE: [u8; 2] = [0x55, 0xAA];
|
||||||
|
const PARTID_FAT12: u8 = 0x01;
|
||||||
|
const PARTID_FAT16_LESS32M: u8 = 0x04;
|
||||||
|
const PARTID_FAT16: u8 = 0x06;
|
||||||
|
const PARTID_FAT32: u8 = 0x0B;
|
||||||
|
const PARTID_FAT32_LBA: u8 = 0x0C;
|
||||||
|
|
||||||
|
fn cmd_error_to_io_error(_: CmdTransferError) -> Error {
|
||||||
|
Error::new(ErrorKind::Other, "Command transfer error")
|
||||||
|
}
|
||||||
|
|
||||||
|
const BLOCK_SIZE: usize = 512;
|
||||||
|
|
||||||
|
/// SdReader struct implementing `Read + BufRead + Write + Seek` traits for `core_io`.
|
||||||
|
/// Used as an adaptor for fatfs crate, but could be used directly for raw data access.
|
||||||
|
///
|
||||||
|
/// Implementation: all read/writes would be split into unaligned and block-aligned parts,
|
||||||
|
/// unaligned read/writes would do a buffered read/write using a block-sized internal buffer,
|
||||||
|
/// while aligned transactions would be sent to the SD card directly for performance reason.
|
||||||
|
pub struct SdReader {
|
||||||
|
/// Internal SdCard handle.
|
||||||
|
sd: SdCard,
|
||||||
|
/// Read buffer with the size of 1 block.
|
||||||
|
buffer: Vec<u8>,
|
||||||
|
/// Address for the next byte.
|
||||||
|
byte_addr: u32,
|
||||||
|
/// Internal index for the next byte.
|
||||||
|
/// Normally in range `[0, BLOCK_SIZE - 1]`.
|
||||||
|
///
|
||||||
|
/// `index = BLOCK_SIZE` means that the `buffer` is invalid for the current `byte_addr`,
|
||||||
|
/// the next `fill_buf` call would fill the buffer.
|
||||||
|
index: usize,
|
||||||
|
/// Dirty flag indicating the content has to be flushed.
|
||||||
|
dirty: bool,
|
||||||
|
/// Base offset for translation from logical address to physical address.
|
||||||
|
offset: u32,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Copy, Clone)]
|
||||||
|
#[allow(unused)]
|
||||||
|
// Partition entry enum, normally we would use entry1.
|
||||||
|
pub enum PartitionEntry {
|
||||||
|
Entry1 = 0x1BE,
|
||||||
|
Entry2 = 0x1CE,
|
||||||
|
Entry3 = 0x1DE,
|
||||||
|
Entry4 = 0x1EE,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SdReader {
|
||||||
|
/// Create SdReader from SdCard
|
||||||
|
pub fn new(sd: SdCard) -> SdReader {
|
||||||
|
let mut vec: Vec<u8> = Vec::with_capacity(BLOCK_SIZE);
|
||||||
|
unsafe {
|
||||||
|
vec.set_len(vec.capacity());
|
||||||
|
}
|
||||||
|
SdReader {
|
||||||
|
sd,
|
||||||
|
buffer: vec,
|
||||||
|
byte_addr: 0,
|
||||||
|
index: BLOCK_SIZE,
|
||||||
|
dirty: false,
|
||||||
|
offset: 0,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Internal read function for unaligned read.
|
||||||
|
/// The read must not cross block boundary.
|
||||||
|
fn read_unaligned(&mut self, buf: &mut [u8]) -> IoResult<usize> {
|
||||||
|
if buf.len() == 0 {
|
||||||
|
return Ok(0);
|
||||||
|
}
|
||||||
|
let filled_buffer = self.fill_buf()?;
|
||||||
|
for (dest, src) in buf.iter_mut().zip(filled_buffer.iter()) {
|
||||||
|
*dest = *src;
|
||||||
|
}
|
||||||
|
self.consume(buf.len());
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Internal write function for unaligned write.
|
||||||
|
/// The write must not cross block boundary.
|
||||||
|
fn write_unaligned(&mut self, buf: &[u8]) -> IoResult<usize> {
|
||||||
|
if buf.len() == 0 {
|
||||||
|
return Ok(0);
|
||||||
|
}
|
||||||
|
// update buffer if needed, as we will flush the entire block later.
|
||||||
|
self.fill_buf()?;
|
||||||
|
self.dirty = true;
|
||||||
|
let dest_buffer = &mut self.buffer[self.index..];
|
||||||
|
for (src, dest) in buf.iter().zip(dest_buffer.iter_mut()) {
|
||||||
|
*dest = *src;
|
||||||
|
}
|
||||||
|
self.consume(buf.len());
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Split the slice into three segments, with the middle block-aligned.
|
||||||
|
/// Alignment depends on the current `self.byte_addr` instead of the slice pointer address
|
||||||
|
fn block_align<'b>(&self, buf: &'b [u8]) -> (&'b [u8], &'b [u8], &'b [u8]) {
|
||||||
|
let head_len = BLOCK_SIZE - (self.byte_addr as usize % BLOCK_SIZE);
|
||||||
|
if head_len > buf.len() {
|
||||||
|
(buf, &[], &[])
|
||||||
|
} else {
|
||||||
|
let remaining_length = buf.len() - head_len;
|
||||||
|
let mid_length = remaining_length - remaining_length % BLOCK_SIZE;
|
||||||
|
let (head, remaining) = buf.split_at(head_len);
|
||||||
|
let (mid, tail) = remaining.split_at(mid_length);
|
||||||
|
(head, mid, tail)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Split the mutable slice into three segments, with the middle block-aligned.
|
||||||
|
/// Alignment depends on the current `self.byte_addr` instead of the slice pointer address
|
||||||
|
fn block_align_mut<'b>(&self, buf: &'b mut [u8]) -> (&'b mut [u8], &'b mut [u8], &'b mut [u8]) {
|
||||||
|
let head_len = BLOCK_SIZE - (self.byte_addr as usize % BLOCK_SIZE);
|
||||||
|
if head_len > buf.len() {
|
||||||
|
(buf, &mut [], &mut [])
|
||||||
|
} else {
|
||||||
|
let remaining_length = buf.len() - head_len;
|
||||||
|
let mid_length = remaining_length - remaining_length % BLOCK_SIZE;
|
||||||
|
let (head, remaining) = buf.split_at_mut(head_len);
|
||||||
|
let (mid, tail) = remaining.split_at_mut(mid_length);
|
||||||
|
(head, mid, tail)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Invalidate the buffer, so later unaligned read/write would reload the buffer from SD card.
|
||||||
|
fn invalidate_buffer(&mut self) {
|
||||||
|
self.index = BLOCK_SIZE;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the base offset of the SD card, to transform from physical address to logical address.
|
||||||
|
fn set_base_offset(&mut self, offset: u32) -> IoResult<u64> {
|
||||||
|
self.offset = offset;
|
||||||
|
self.seek(SeekFrom::Start(0))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Mount fatfs from partition entry, and return the fatfs object if success.
|
||||||
|
/// This takes the ownership of self, so currently there is no way to recover from an error,
|
||||||
|
/// except creating a new SD card instance.
|
||||||
|
pub fn mount_fatfs(mut self, entry: PartitionEntry) -> IoResult<fatfs::FileSystem<Self>> {
|
||||||
|
let mut buffer: [u8; 4] = [0; 4];
|
||||||
|
self.seek(SeekFrom::Start(0x1FE))?;
|
||||||
|
self.read_exact(&mut buffer[..2])?;
|
||||||
|
// check MBR signature
|
||||||
|
if buffer[..2] != MBR_SIGNATURE {
|
||||||
|
return Err(Error::new(
|
||||||
|
ErrorKind::InvalidData,
|
||||||
|
"Incorrect signature for MBR sector.",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
// Read partition ID.
|
||||||
|
self.seek(SeekFrom::Start(entry as u64 + 0x4))?;
|
||||||
|
self.read_exact(&mut buffer[..1])?;
|
||||||
|
debug!("Partition ID: {:0X}", buffer[0]);
|
||||||
|
match buffer[0] {
|
||||||
|
PARTID_FAT12 | PARTID_FAT16_LESS32M | PARTID_FAT16 |
|
||||||
|
PARTID_FAT32 | PARTID_FAT32_LBA => {}
|
||||||
|
_ => {
|
||||||
|
return Err(Error::new(
|
||||||
|
ErrorKind::InvalidData,
|
||||||
|
"No FAT partition found for the specified entry.",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Read LBA
|
||||||
|
self.seek(SeekFrom::Current(0x3))?;
|
||||||
|
self.read_exact(&mut buffer)?;
|
||||||
|
let mut lba: u32 = 0;
|
||||||
|
// Little endian
|
||||||
|
for i in 0..4 {
|
||||||
|
lba |= (buffer[i] as u32) << (i * 8);
|
||||||
|
}
|
||||||
|
// Set to logical address
|
||||||
|
self.set_base_offset(lba * BLOCK_SIZE as u32)?;
|
||||||
|
// setup fatfs
|
||||||
|
fatfs::FileSystem::new(self, fatfs::FsOptions::new())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Read for SdReader {
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
|
||||||
|
let total_length = buf.len();
|
||||||
|
let (a, b, c) = self.block_align_mut(buf);
|
||||||
|
self.read_unaligned(a)?;
|
||||||
|
if b.len() > 0 {
|
||||||
|
// invalidate internal buffer
|
||||||
|
self.invalidate_buffer();
|
||||||
|
if let Err(_) = self.sd.read_block(
|
||||||
|
self.byte_addr / BLOCK_SIZE as u32,
|
||||||
|
(b.len() / BLOCK_SIZE) as u16,
|
||||||
|
b,
|
||||||
|
) {
|
||||||
|
// we have to allow partial read, as per the trait required
|
||||||
|
return Ok(a.len());
|
||||||
|
}
|
||||||
|
self.byte_addr += b.len() as u32;
|
||||||
|
}
|
||||||
|
if let Err(_) = self.read_unaligned(c) {
|
||||||
|
// we have to allow partial read, as per the trait required
|
||||||
|
return Ok(a.len() + b.len());
|
||||||
|
}
|
||||||
|
Ok(total_length)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BufRead for SdReader {
|
||||||
|
fn fill_buf(&mut self) -> IoResult<&[u8]> {
|
||||||
|
if self.index == BLOCK_SIZE {
|
||||||
|
// flush the buffer if it is dirty before overwriting it with new data
|
||||||
|
if self.dirty {
|
||||||
|
self.flush()?;
|
||||||
|
}
|
||||||
|
// reload buffer
|
||||||
|
self.sd
|
||||||
|
.read_block(self.byte_addr / (BLOCK_SIZE as u32), 1, &mut self.buffer)
|
||||||
|
.map_err(cmd_error_to_io_error)?;
|
||||||
|
self.index = (self.byte_addr as usize) % BLOCK_SIZE;
|
||||||
|
}
|
||||||
|
Ok(&self.buffer[self.index..])
|
||||||
|
}
|
||||||
|
|
||||||
|
fn consume(&mut self, amt: usize) {
|
||||||
|
self.index += amt;
|
||||||
|
self.byte_addr += amt as u32;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Write for SdReader {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> IoResult<usize> {
|
||||||
|
let (a, b, c) = self.block_align(buf);
|
||||||
|
self.write_unaligned(a)?;
|
||||||
|
if b.len() > 0 {
|
||||||
|
self.flush()?;
|
||||||
|
self.invalidate_buffer();
|
||||||
|
if let Err(_) = self.sd.write_block(
|
||||||
|
self.byte_addr / BLOCK_SIZE as u32,
|
||||||
|
(b.len() / BLOCK_SIZE) as u16,
|
||||||
|
b,
|
||||||
|
) {
|
||||||
|
return Ok(a.len());
|
||||||
|
}
|
||||||
|
self.byte_addr += b.len() as u32;
|
||||||
|
}
|
||||||
|
if let Err(_) = self.write_unaligned(c) {
|
||||||
|
return Ok(a.len() + b.len());
|
||||||
|
}
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn flush(&mut self) -> IoResult<()> {
|
||||||
|
if self.dirty {
|
||||||
|
let block_addr = (self.byte_addr - self.index as u32) / (BLOCK_SIZE as u32);
|
||||||
|
self.sd
|
||||||
|
.write_block(block_addr, 1, &self.buffer)
|
||||||
|
.map_err(cmd_error_to_io_error)?;
|
||||||
|
self.dirty = false;
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Seek for SdReader {
|
||||||
|
fn seek(&mut self, pos: SeekFrom) -> IoResult<u64> {
|
||||||
|
let raw_target = match pos {
|
||||||
|
SeekFrom::Start(x) => self.offset as i64 + x as i64,
|
||||||
|
SeekFrom::Current(x) => self.byte_addr as i64 + x,
|
||||||
|
SeekFrom::End(_) => panic!("SD card does not support seek from end"),
|
||||||
|
};
|
||||||
|
if raw_target < self.offset as i64 || raw_target > core::u32::MAX as i64 {
|
||||||
|
return Err(Error::new(ErrorKind::InvalidInput, "Invalid address"));
|
||||||
|
}
|
||||||
|
let target_byte_addr = raw_target as u32;
|
||||||
|
let address_same_block =
|
||||||
|
self.byte_addr / (BLOCK_SIZE as u32) == target_byte_addr / (BLOCK_SIZE as u32);
|
||||||
|
// if the buffer was invalidated, we consider seek as different block
|
||||||
|
let same_block = address_same_block && self.index != BLOCK_SIZE;
|
||||||
|
if !same_block {
|
||||||
|
self.flush()?;
|
||||||
|
}
|
||||||
|
self.byte_addr = target_byte_addr;
|
||||||
|
self.index = if same_block {
|
||||||
|
target_byte_addr as usize % BLOCK_SIZE
|
||||||
|
} else {
|
||||||
|
// invalidate the buffer as we moved to a different block
|
||||||
|
BLOCK_SIZE
|
||||||
|
};
|
||||||
|
Ok((self.byte_addr - self.offset) as u64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for SdReader {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
// just try to flush it, ignore error if any
|
||||||
|
self.flush().unwrap_or(());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,14 @@
|
||||||
|
[package]
|
||||||
|
authors = ["M-Labs"]
|
||||||
|
name = "core_io"
|
||||||
|
version = "0.1.20200410"
|
||||||
|
|
||||||
|
[lib]
|
||||||
|
name = "core_io"
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
memchr = { version = "2", default-features = false, optional = true }
|
||||||
|
|
||||||
|
[features]
|
||||||
|
alloc = []
|
||||||
|
collections = ["alloc", "memchr"]
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,896 @@
|
||||||
|
use crate::io::prelude::*;
|
||||||
|
|
||||||
|
use core::cmp;
|
||||||
|
use crate::io::{self, Error, ErrorKind, Initializer, SeekFrom};
|
||||||
|
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
use core::convert::TryInto;
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
use collections::vec::Vec;
|
||||||
|
|
||||||
|
#[cfg(feature = "alloc")]
|
||||||
|
use alloc::boxed::Box;
|
||||||
|
|
||||||
|
/// A `Cursor` wraps an in-memory buffer and provides it with a
|
||||||
|
/// [`Seek`] implementation.
|
||||||
|
///
|
||||||
|
/// `Cursor`s are used with in-memory buffers, anything implementing
|
||||||
|
/// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],
|
||||||
|
/// allowing these buffers to be used anywhere you might use a reader or writer
|
||||||
|
/// that does actual I/O.
|
||||||
|
///
|
||||||
|
/// The standard library implements some I/O traits on various types which
|
||||||
|
/// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and
|
||||||
|
/// `Cursor<`[`&[u8]`][bytes]`>`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// We may want to write bytes to a [`File`] in our production
|
||||||
|
/// code, but use an in-memory buffer in our tests. We can do this with
|
||||||
|
/// `Cursor`:
|
||||||
|
///
|
||||||
|
/// [`Seek`]: trait.Seek.html
|
||||||
|
/// [`Read`]: ../../std/io/trait.Read.html
|
||||||
|
/// [`Write`]: ../../std/io/trait.Write.html
|
||||||
|
/// [`Vec`]: ../../std/vec/struct.Vec.html
|
||||||
|
/// [bytes]: ../../std/primitive.slice.html
|
||||||
|
/// [`File`]: ../fs/struct.File.html
|
||||||
|
///
|
||||||
|
/// ```no_run
|
||||||
|
/// use std::io::prelude::*;
|
||||||
|
/// use std::io::{self, SeekFrom};
|
||||||
|
/// use std::fs::File;
|
||||||
|
///
|
||||||
|
/// // a library function we've written
|
||||||
|
/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {
|
||||||
|
/// writer.seek(SeekFrom::End(-10))?;
|
||||||
|
///
|
||||||
|
/// for i in 0..10 {
|
||||||
|
/// writer.write(&[i])?;
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// // all went well
|
||||||
|
/// Ok(())
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// # fn foo() -> io::Result<()> {
|
||||||
|
/// // Here's some code that uses this library function.
|
||||||
|
/// //
|
||||||
|
/// // We might want to use a BufReader here for efficiency, but let's
|
||||||
|
/// // keep this example focused.
|
||||||
|
/// let mut file = File::create("foo.txt")?;
|
||||||
|
///
|
||||||
|
/// write_ten_bytes_at_end(&mut file)?;
|
||||||
|
/// # Ok(())
|
||||||
|
/// # }
|
||||||
|
///
|
||||||
|
/// // now let's write a test
|
||||||
|
/// #[test]
|
||||||
|
/// fn test_writes_bytes() {
|
||||||
|
/// // setting up a real File is much slower than an in-memory buffer,
|
||||||
|
/// // let's use a cursor instead
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
/// let mut buff = Cursor::new(vec![0; 15]);
|
||||||
|
///
|
||||||
|
/// write_ten_bytes_at_end(&mut buff).unwrap();
|
||||||
|
///
|
||||||
|
/// assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[derive(Clone, Debug, Default, Eq, PartialEq)]
|
||||||
|
pub struct Cursor<T> {
|
||||||
|
inner: T,
|
||||||
|
pos: u64,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> Cursor<T> {
|
||||||
|
/// Creates a new cursor wrapping the provided underlying in-memory buffer.
|
||||||
|
///
|
||||||
|
/// Cursor initial position is `0` even if underlying buffer (e.g., `Vec`)
|
||||||
|
/// is not empty. So writing to cursor starts with overwriting `Vec`
|
||||||
|
/// content, not with appending to it.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
/// ```
|
||||||
|
pub fn new(inner: T) -> Cursor<T> {
|
||||||
|
Cursor { pos: 0, inner }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Consumes this cursor, returning the underlying value.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let vec = buff.into_inner();
|
||||||
|
/// ```
|
||||||
|
pub fn into_inner(self) -> T {
|
||||||
|
self.inner
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets a reference to the underlying value in this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let reference = buff.get_ref();
|
||||||
|
/// ```
|
||||||
|
pub fn get_ref(&self) -> &T {
|
||||||
|
&self.inner
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Gets a mutable reference to the underlying value in this cursor.
|
||||||
|
///
|
||||||
|
/// Care should be taken to avoid modifying the internal I/O state of the
|
||||||
|
/// underlying value as it may corrupt this cursor's position.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(Vec::new());
|
||||||
|
/// # fn force_inference(_: &Cursor<Vec<u8>>) {}
|
||||||
|
/// # force_inference(&buff);
|
||||||
|
///
|
||||||
|
/// let reference = buff.get_mut();
|
||||||
|
/// ```
|
||||||
|
pub fn get_mut(&mut self) -> &mut T {
|
||||||
|
&mut self.inner
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the current position of this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
/// use std::io::prelude::*;
|
||||||
|
/// use std::io::SeekFrom;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||||||
|
///
|
||||||
|
/// assert_eq!(buff.position(), 0);
|
||||||
|
///
|
||||||
|
/// buff.seek(SeekFrom::Current(2)).unwrap();
|
||||||
|
/// assert_eq!(buff.position(), 2);
|
||||||
|
///
|
||||||
|
/// buff.seek(SeekFrom::Current(-1)).unwrap();
|
||||||
|
/// assert_eq!(buff.position(), 1);
|
||||||
|
/// ```
|
||||||
|
pub fn position(&self) -> u64 {
|
||||||
|
self.pos
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Sets the position of this cursor.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::Cursor;
|
||||||
|
///
|
||||||
|
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
|
||||||
|
///
|
||||||
|
/// assert_eq!(buff.position(), 0);
|
||||||
|
///
|
||||||
|
/// buff.set_position(2);
|
||||||
|
/// assert_eq!(buff.position(), 2);
|
||||||
|
///
|
||||||
|
/// buff.set_position(4);
|
||||||
|
/// assert_eq!(buff.position(), 4);
|
||||||
|
/// ```
|
||||||
|
pub fn set_position(&mut self, pos: u64) {
|
||||||
|
self.pos = pos;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> io::Seek for Cursor<T>
|
||||||
|
where
|
||||||
|
T: AsRef<[u8]>,
|
||||||
|
{
|
||||||
|
fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {
|
||||||
|
let (base_pos, offset) = match style {
|
||||||
|
SeekFrom::Start(n) => {
|
||||||
|
self.pos = n;
|
||||||
|
return Ok(n);
|
||||||
|
}
|
||||||
|
SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),
|
||||||
|
SeekFrom::Current(n) => (self.pos, n),
|
||||||
|
};
|
||||||
|
let new_pos = if offset >= 0 {
|
||||||
|
base_pos.checked_add(offset as u64)
|
||||||
|
} else {
|
||||||
|
base_pos.checked_sub((offset.wrapping_neg()) as u64)
|
||||||
|
};
|
||||||
|
match new_pos {
|
||||||
|
Some(n) => {
|
||||||
|
self.pos = n;
|
||||||
|
Ok(self.pos)
|
||||||
|
}
|
||||||
|
None => Err(Error::new(
|
||||||
|
ErrorKind::InvalidInput,
|
||||||
|
"invalid seek to a negative or overflowing position",
|
||||||
|
)),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn stream_len(&mut self) -> io::Result<u64> {
|
||||||
|
Ok(self.inner.as_ref().len() as u64)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn stream_position(&mut self) -> io::Result<u64> {
|
||||||
|
Ok(self.pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> Read for Cursor<T>
|
||||||
|
where
|
||||||
|
T: AsRef<[u8]>,
|
||||||
|
{
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
let n = Read::read(&mut self.get_ref().as_ref(), buf)?;
|
||||||
|
self.pos += n as u64;
|
||||||
|
Ok(n)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
let n = buf.len();
|
||||||
|
Read::read_exact(&mut self.get_ref().as_ref(), buf)?;
|
||||||
|
self.pos += n as u64;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn initializer(&self) -> Initializer {
|
||||||
|
Initializer::nop()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
impl<T> BufRead for Cursor<T>
|
||||||
|
where
|
||||||
|
T: AsRef<[u8]>,
|
||||||
|
{
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);
|
||||||
|
Ok(&self.inner.as_ref()[(amt as usize)..])
|
||||||
|
}
|
||||||
|
fn consume(&mut self, amt: usize) {
|
||||||
|
self.pos += amt as u64;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Non-resizing write implementation
|
||||||
|
#[inline]
|
||||||
|
fn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {
|
||||||
|
let pos = cmp::min(*pos_mut, slice.len() as u64);
|
||||||
|
let amt = (&mut slice[(pos as usize)..]).write(buf)?;
|
||||||
|
*pos_mut += amt as u64;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Resizing write implementation
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
fn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
let pos: usize = (*pos_mut).try_into().map_err(|_| {
|
||||||
|
Error::new(
|
||||||
|
ErrorKind::InvalidInput,
|
||||||
|
"cursor position exceeds maximum possible vector length",
|
||||||
|
)
|
||||||
|
})?;
|
||||||
|
// Make sure the internal buffer is as least as big as where we
|
||||||
|
// currently are
|
||||||
|
let len = vec.len();
|
||||||
|
if len < pos {
|
||||||
|
// use `resize` so that the zero filling is as efficient as possible
|
||||||
|
vec.resize(pos, 0);
|
||||||
|
}
|
||||||
|
// Figure out what bytes will be used to overwrite what's currently
|
||||||
|
// there (left), and what will be appended on the end (right)
|
||||||
|
{
|
||||||
|
let space = vec.len() - pos;
|
||||||
|
let (left, right) = buf.split_at(cmp::min(space, buf.len()));
|
||||||
|
vec[pos..pos + left.len()].copy_from_slice(left);
|
||||||
|
vec.extend_from_slice(right);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Bump us forward
|
||||||
|
*pos_mut = (pos + buf.len()) as u64;
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Write for Cursor<&mut [u8]> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
slice_write(&mut self.pos, self.inner, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
impl Write for Cursor<&mut Vec<u8>> {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
vec_write(&mut self.pos, self.inner, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
impl Write for Cursor<Vec<u8>> {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
vec_write(&mut self.pos, &mut self.inner, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature = "alloc")]
|
||||||
|
impl Write for Cursor<Box<[u8]>> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
slice_write(&mut self.pos, &mut self.inner, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use crate::io::prelude::*;
|
||||||
|
use crate::io::{Cursor, IoSlice, IoSliceMut, SeekFrom};
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_vec_writer() {
|
||||||
|
let mut writer = Vec::new();
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(
|
||||||
|
writer
|
||||||
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||||||
|
.unwrap(),
|
||||||
|
3
|
||||||
|
);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||||
|
assert_eq!(writer, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_writer() {
|
||||||
|
let mut writer = Cursor::new(Vec::new());
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(
|
||||||
|
writer
|
||||||
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||||||
|
.unwrap(),
|
||||||
|
3
|
||||||
|
);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_mut_writer() {
|
||||||
|
let mut vec = Vec::new();
|
||||||
|
let mut writer = Cursor::new(&mut vec);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(
|
||||||
|
writer
|
||||||
|
.write_vectored(&[IoSlice::new(&[]), IoSlice::new(&[8, 9]), IoSlice::new(&[10])],)
|
||||||
|
.unwrap(),
|
||||||
|
3
|
||||||
|
);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_box_slice_writer() {
|
||||||
|
let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(&**writer.get_ref(), b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_box_slice_writer_vectored() {
|
||||||
|
let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(
|
||||||
|
writer
|
||||||
|
.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7]),])
|
||||||
|
.unwrap(),
|
||||||
|
7,
|
||||||
|
);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(&**writer.get_ref(), b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer() {
|
||||||
|
let mut buf = [0 as u8; 9];
|
||||||
|
{
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write(&[8, 9]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[10]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer_vectored() {
|
||||||
|
let mut buf = [0 as u8; 9];
|
||||||
|
{
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[0])]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(
|
||||||
|
writer
|
||||||
|
.write_vectored(&[IoSlice::new(&[1, 2, 3]), IoSlice::new(&[4, 5, 6, 7])],)
|
||||||
|
.unwrap(),
|
||||||
|
7,
|
||||||
|
);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
assert_eq!(writer.write_vectored(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[8, 9])]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write_vectored(&[IoSlice::new(&[10])]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer_seek() {
|
||||||
|
let mut buf = [0 as u8; 8];
|
||||||
|
{
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);
|
||||||
|
assert_eq!(writer.position(), 2);
|
||||||
|
assert_eq!(writer.write(&[2]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 3);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[3]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 2);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||||||
|
assert_eq!(writer.position(), 7);
|
||||||
|
assert_eq!(writer.write(&[4]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
}
|
||||||
|
let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_writer_error() {
|
||||||
|
let mut buf = [0 as u8; 2];
|
||||||
|
let mut writer = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_reader() {
|
||||||
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_mem_reader_vectored() {
|
||||||
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||||||
|
.unwrap(),
|
||||||
|
1,
|
||||||
|
);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf1 = [0; 4];
|
||||||
|
let mut buf2 = [0; 4];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2),])
|
||||||
|
.unwrap(),
|
||||||
|
7,
|
||||||
|
);
|
||||||
|
let b1: &[_] = &[1, 2, 3, 4];
|
||||||
|
let b2: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(buf1, b1);
|
||||||
|
assert_eq!(&buf2[..3], b2);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_boxed_slice_reader() {
|
||||||
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_boxed_slice_reader_vectored() {
|
||||||
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||||||
|
.unwrap(),
|
||||||
|
1,
|
||||||
|
);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf1 = [0; 4];
|
||||||
|
let mut buf2 = [0; 4];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
|
||||||
|
.unwrap(),
|
||||||
|
7,
|
||||||
|
);
|
||||||
|
let b1: &[_] = &[1, 2, 3, 4];
|
||||||
|
let b2: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(buf1, b1);
|
||||||
|
assert_eq!(&buf2[..3], b2);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn read_to_end() {
|
||||||
|
let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
let mut v = Vec::new();
|
||||||
|
reader.read_to_end(&mut v).unwrap();
|
||||||
|
assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_slice_reader() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let reader = &mut &in_buf[..];
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.len(), 7);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(&buf[..], b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.len(), 3);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(&buf[..], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_slice_reader_vectored() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let reader = &mut &in_buf[..];
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read_vectored(&mut [IoSliceMut::new(&mut buf)]).unwrap(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut []), IoSliceMut::new(&mut buf),])
|
||||||
|
.unwrap(),
|
||||||
|
1,
|
||||||
|
);
|
||||||
|
assert_eq!(reader.len(), 7);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf1 = [0; 4];
|
||||||
|
let mut buf2 = [0; 4];
|
||||||
|
assert_eq!(
|
||||||
|
reader
|
||||||
|
.read_vectored(&mut [IoSliceMut::new(&mut buf1), IoSliceMut::new(&mut buf2)],)
|
||||||
|
.unwrap(),
|
||||||
|
7,
|
||||||
|
);
|
||||||
|
let b1: &[_] = &[1, 2, 3, 4];
|
||||||
|
let b2: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(buf1, b1);
|
||||||
|
assert_eq!(&buf2[..3], b2);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_read_exact() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let reader = &mut &in_buf[..];
|
||||||
|
let mut buf = [];
|
||||||
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||||||
|
let mut buf = [8];
|
||||||
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||||||
|
assert_eq!(buf[0], 0);
|
||||||
|
assert_eq!(reader.len(), 7);
|
||||||
|
let mut buf = [0, 0, 0, 0, 0, 0, 0];
|
||||||
|
assert!(reader.read_exact(&mut buf).is_ok());
|
||||||
|
assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);
|
||||||
|
assert_eq!(reader.len(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert!(reader.read_exact(&mut buf).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_buf_reader() {
|
||||||
|
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
let mut reader = Cursor::new(&in_buf[..]);
|
||||||
|
let mut buf = [];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
assert_eq!(reader.position(), 0);
|
||||||
|
let mut buf = [0];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 1);
|
||||||
|
assert_eq!(reader.position(), 1);
|
||||||
|
let b: &[_] = &[0];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
let mut buf = [0; 4];
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 4);
|
||||||
|
assert_eq!(reader.position(), 5);
|
||||||
|
let b: &[_] = &[1, 2, 3, 4];
|
||||||
|
assert_eq!(buf, b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 3);
|
||||||
|
let b: &[_] = &[5, 6, 7];
|
||||||
|
assert_eq!(&buf[..3], b);
|
||||||
|
assert_eq!(reader.read(&mut buf).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn seek_past_end() {
|
||||||
|
let buf = [0xff];
|
||||||
|
let mut r = Cursor::new(&buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.read(&mut [0]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut buf = [0];
|
||||||
|
let mut r = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn seek_past_i64() {
|
||||||
|
let buf = [0xff];
|
||||||
|
let mut r = Cursor::new(&buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||||||
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||||||
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||||||
|
|
||||||
|
let mut buf = [0];
|
||||||
|
let mut r = Cursor::new(&mut buf[..]);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||||||
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);
|
||||||
|
assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn seek_before_0() {
|
||||||
|
let buf = [0xff];
|
||||||
|
let mut r = Cursor::new(&buf[..]);
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10]);
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut buf = [0];
|
||||||
|
let mut r = Cursor::new(&mut buf[..]);
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
|
||||||
|
let mut r = Cursor::new(vec![10].into_boxed_slice());
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_seekable_mem_writer() {
|
||||||
|
let mut writer = Cursor::new(Vec::<u8>::new());
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(writer.position(), 1);
|
||||||
|
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
|
||||||
|
assert_eq!(writer.position(), 8);
|
||||||
|
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
|
||||||
|
assert_eq!(writer.position(), 0);
|
||||||
|
assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
|
||||||
|
assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
|
||||||
|
assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
|
||||||
|
assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
|
||||||
|
assert_eq!(writer.write(&[1]).unwrap(), 1);
|
||||||
|
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
|
||||||
|
assert_eq!(&writer.get_ref()[..], b);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn vec_seek_past_end() {
|
||||||
|
let mut r = Cursor::new(Vec::new());
|
||||||
|
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
|
||||||
|
assert_eq!(r.write(&[3]).unwrap(), 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn vec_seek_before_0() {
|
||||||
|
let mut r = Cursor::new(Vec::new());
|
||||||
|
assert!(r.seek(SeekFrom::End(-2)).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
#[cfg(target_pointer_width = "32")]
|
||||||
|
fn vec_seek_and_write_past_usize_max() {
|
||||||
|
let mut c = Cursor::new(Vec::new());
|
||||||
|
c.set_position(<usize>::max_value() as u64 + 1);
|
||||||
|
assert!(c.write_all(&[1, 2, 3]).is_err());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_partial_eq() {
|
||||||
|
assert_eq!(Cursor::new(Vec::<u8>::new()), Cursor::new(Vec::<u8>::new()));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_eq() {
|
||||||
|
struct AssertEq<T: Eq>(pub T);
|
||||||
|
|
||||||
|
let _: AssertEq<Cursor<Vec<u8>>> = AssertEq(Cursor::new(Vec::new()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,551 @@
|
||||||
|
#[cfg(feature="alloc")] use alloc::boxed::Box;
|
||||||
|
#[cfg(not(feature="alloc"))] use ::FakeBox as Box;
|
||||||
|
use core::convert::Into;
|
||||||
|
use core::fmt;
|
||||||
|
use core::marker::{Send, Sync};
|
||||||
|
use core::option::Option::{self, Some, None};
|
||||||
|
use core::result;
|
||||||
|
#[cfg(feature="collections")] use collections::string::String;
|
||||||
|
#[cfg(not(feature="collections"))] use ::ErrorString as String;
|
||||||
|
use core::convert::From;
|
||||||
|
|
||||||
|
/// A specialized [`Result`](../result/enum.Result.html) type for I/O
|
||||||
|
/// operations.
|
||||||
|
///
|
||||||
|
/// This type is broadly used across [`std::io`] for any operation which may
|
||||||
|
/// produce an error.
|
||||||
|
///
|
||||||
|
/// This typedef is generally used to avoid writing out [`io::Error`] directly and
|
||||||
|
/// is otherwise a direct mapping to [`Result`].
|
||||||
|
///
|
||||||
|
/// While usual Rust style is to import types directly, aliases of [`Result`]
|
||||||
|
/// often are not, to make it easier to distinguish between them. [`Result`] is
|
||||||
|
/// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias
|
||||||
|
/// will generally use `io::Result` instead of shadowing the prelude's import
|
||||||
|
/// of [`std::result::Result`][`Result`].
|
||||||
|
///
|
||||||
|
/// [`std::io`]: ../io/index.html
|
||||||
|
/// [`io::Error`]: ../io/struct.Error.html
|
||||||
|
/// [`Result`]: ../result/enum.Result.html
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// A convenience function that bubbles an `io::Result` to its caller:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// fn get_string() -> io::Result<String> {
|
||||||
|
/// let mut buffer = String::new();
|
||||||
|
///
|
||||||
|
/// io::stdin().read_line(&mut buffer)?;
|
||||||
|
///
|
||||||
|
/// Ok(buffer)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub type Result<T> = result::Result<T, Error>;
|
||||||
|
|
||||||
|
/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and
|
||||||
|
/// associated traits.
|
||||||
|
///
|
||||||
|
/// Errors mostly originate from the underlying OS, but custom instances of
|
||||||
|
/// `Error` can be created with crafted error messages and a particular value of
|
||||||
|
/// [`ErrorKind`].
|
||||||
|
///
|
||||||
|
/// [`Read`]: ../io/trait.Read.html
|
||||||
|
/// [`Write`]: ../io/trait.Write.html
|
||||||
|
/// [`Seek`]: ../io/trait.Seek.html
|
||||||
|
/// [`ErrorKind`]: enum.ErrorKind.html
|
||||||
|
pub struct Error {
|
||||||
|
repr: Repr,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Error {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
fmt::Debug::fmt(&self.repr, f)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
enum Repr {
|
||||||
|
Os(i32),
|
||||||
|
Simple(ErrorKind),
|
||||||
|
#[cfg(feature="alloc")]
|
||||||
|
Custom(Box<Custom>),
|
||||||
|
#[cfg(not(feature="alloc"))]
|
||||||
|
Custom(Custom),
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct Custom {
|
||||||
|
kind: ErrorKind,
|
||||||
|
error: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A list specifying general categories of I/O error.
|
||||||
|
///
|
||||||
|
/// This list is intended to grow over time and it is not recommended to
|
||||||
|
/// exhaustively match against it.
|
||||||
|
///
|
||||||
|
/// It is used with the [`io::Error`] type.
|
||||||
|
///
|
||||||
|
/// [`io::Error`]: struct.Error.html
|
||||||
|
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||||
|
#[allow(deprecated)]
|
||||||
|
#[non_exhaustive]
|
||||||
|
pub enum ErrorKind {
|
||||||
|
/// An entity was not found, often a file.
|
||||||
|
NotFound,
|
||||||
|
/// The operation lacked the necessary privileges to complete.
|
||||||
|
PermissionDenied,
|
||||||
|
/// The connection was refused by the remote server.
|
||||||
|
ConnectionRefused,
|
||||||
|
/// The connection was reset by the remote server.
|
||||||
|
ConnectionReset,
|
||||||
|
/// The connection was aborted (terminated) by the remote server.
|
||||||
|
ConnectionAborted,
|
||||||
|
/// The network operation failed because it was not connected yet.
|
||||||
|
NotConnected,
|
||||||
|
/// A socket address could not be bound because the address is already in
|
||||||
|
/// use elsewhere.
|
||||||
|
AddrInUse,
|
||||||
|
/// A nonexistent interface was requested or the requested address was not
|
||||||
|
/// local.
|
||||||
|
AddrNotAvailable,
|
||||||
|
/// The operation failed because a pipe was closed.
|
||||||
|
BrokenPipe,
|
||||||
|
/// An entity already exists, often a file.
|
||||||
|
AlreadyExists,
|
||||||
|
/// The operation needs to block to complete, but the blocking operation was
|
||||||
|
/// requested to not occur.
|
||||||
|
WouldBlock,
|
||||||
|
/// A parameter was incorrect.
|
||||||
|
InvalidInput,
|
||||||
|
/// Data not valid for the operation were encountered.
|
||||||
|
///
|
||||||
|
/// Unlike [`InvalidInput`], this typically means that the operation
|
||||||
|
/// parameters were valid, however the error was caused by malformed
|
||||||
|
/// input data.
|
||||||
|
///
|
||||||
|
/// For example, a function that reads a file into a string will error with
|
||||||
|
/// `InvalidData` if the file's contents are not valid UTF-8.
|
||||||
|
///
|
||||||
|
/// [`InvalidInput`]: #variant.InvalidInput
|
||||||
|
InvalidData,
|
||||||
|
/// The I/O operation's timeout expired, causing it to be canceled.
|
||||||
|
TimedOut,
|
||||||
|
/// An error returned when an operation could not be completed because a
|
||||||
|
/// call to [`write`] returned [`Ok(0)`].
|
||||||
|
///
|
||||||
|
/// This typically means that an operation could only succeed if it wrote a
|
||||||
|
/// particular number of bytes but only a smaller number of bytes could be
|
||||||
|
/// written.
|
||||||
|
///
|
||||||
|
/// [`write`]: ../../std/io/trait.Write.html#tymethod.write
|
||||||
|
/// [`Ok(0)`]: ../../std/io/type.Result.html
|
||||||
|
WriteZero,
|
||||||
|
/// This operation was interrupted.
|
||||||
|
///
|
||||||
|
/// Interrupted operations can typically be retried.
|
||||||
|
Interrupted,
|
||||||
|
/// Any I/O error not part of this list.
|
||||||
|
Other,
|
||||||
|
|
||||||
|
/// An error returned when an operation could not be completed because an
|
||||||
|
/// "end of file" was reached prematurely.
|
||||||
|
///
|
||||||
|
/// This typically means that an operation could only succeed if it read a
|
||||||
|
/// particular number of bytes but only a smaller number of bytes could be
|
||||||
|
/// read.
|
||||||
|
UnexpectedEof,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl ErrorKind {
|
||||||
|
pub(crate) fn as_str(&self) -> &'static str {
|
||||||
|
match *self {
|
||||||
|
ErrorKind::NotFound => "entity not found",
|
||||||
|
ErrorKind::PermissionDenied => "permission denied",
|
||||||
|
ErrorKind::ConnectionRefused => "connection refused",
|
||||||
|
ErrorKind::ConnectionReset => "connection reset",
|
||||||
|
ErrorKind::ConnectionAborted => "connection aborted",
|
||||||
|
ErrorKind::NotConnected => "not connected",
|
||||||
|
ErrorKind::AddrInUse => "address in use",
|
||||||
|
ErrorKind::AddrNotAvailable => "address not available",
|
||||||
|
ErrorKind::BrokenPipe => "broken pipe",
|
||||||
|
ErrorKind::AlreadyExists => "entity already exists",
|
||||||
|
ErrorKind::WouldBlock => "operation would block",
|
||||||
|
ErrorKind::InvalidInput => "invalid input parameter",
|
||||||
|
ErrorKind::InvalidData => "invalid data",
|
||||||
|
ErrorKind::TimedOut => "timed out",
|
||||||
|
ErrorKind::WriteZero => "write zero",
|
||||||
|
ErrorKind::Interrupted => "operation interrupted",
|
||||||
|
ErrorKind::Other => "other os error",
|
||||||
|
ErrorKind::UnexpectedEof => "unexpected end of file",
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Intended for use for errors not exposed to the user, where allocating onto
|
||||||
|
/// the heap (for normal construction via Error::new) is too costly.
|
||||||
|
impl From<ErrorKind> for Error {
|
||||||
|
/// Converts an [`ErrorKind`] into an [`Error`].
|
||||||
|
///
|
||||||
|
/// This conversion allocates a new error with a simple representation of error kind.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// let not_found = ErrorKind::NotFound;
|
||||||
|
/// let error = Error::from(not_found);
|
||||||
|
/// assert_eq!("entity not found", format!("{}", error));
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// [`ErrorKind`]: ../../std/io/enum.ErrorKind.html
|
||||||
|
/// [`Error`]: ../../std/io/struct.Error.html
|
||||||
|
#[inline]
|
||||||
|
fn from(kind: ErrorKind) -> Error {
|
||||||
|
Error { repr: Repr::Simple(kind) }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Error {
|
||||||
|
/// Creates a new I/O error from a known kind of error as well as an
|
||||||
|
/// arbitrary error payload.
|
||||||
|
///
|
||||||
|
/// This function is used to generically create I/O errors which do not
|
||||||
|
/// originate from the OS itself. The `error` argument is an arbitrary
|
||||||
|
/// payload which will be contained in this `Error`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// // errors can be created from strings
|
||||||
|
/// let custom_error = Error::new(ErrorKind::Other, "oh no!");
|
||||||
|
///
|
||||||
|
/// // errors can also be created from other errors
|
||||||
|
/// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);
|
||||||
|
/// ```
|
||||||
|
pub fn new<E>(kind: ErrorKind, error: E) -> Error
|
||||||
|
where
|
||||||
|
E: Into<String>,
|
||||||
|
{
|
||||||
|
Self::_new(kind, error.into())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn _new(kind: ErrorKind, error: String) -> Error {
|
||||||
|
Error { repr: Repr::Custom(Box::new(Custom { kind, error })) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates a new instance of an `Error` from a particular OS error code.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// On Linux:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # if cfg!(target_os = "linux") {
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// let error = io::Error::from_raw_os_error(22);
|
||||||
|
/// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// On Windows:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// # if cfg!(windows) {
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// let error = io::Error::from_raw_os_error(10022);
|
||||||
|
/// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
|
||||||
|
/// # }
|
||||||
|
/// ```
|
||||||
|
pub fn from_raw_os_error(code: i32) -> Error {
|
||||||
|
Error { repr: Repr::Os(code) }
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the OS error that this error represents (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `last_os_error` or
|
||||||
|
/// `from_raw_os_error`, then this function will return `Some`, otherwise
|
||||||
|
/// it will return `None`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// fn print_os_error(err: &Error) {
|
||||||
|
/// if let Some(raw_os_err) = err.raw_os_error() {
|
||||||
|
/// println!("raw OS error: {:?}", raw_os_err);
|
||||||
|
/// } else {
|
||||||
|
/// println!("Not an OS error");
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// // Will print "raw OS error: ...".
|
||||||
|
/// print_os_error(&Error::last_os_error());
|
||||||
|
/// // Will print "Not an OS error".
|
||||||
|
/// print_os_error(&Error::new(ErrorKind::Other, "oh no!"));
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn raw_os_error(&self) -> Option<i32> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(i) => Some(i),
|
||||||
|
Repr::Custom(..) => None,
|
||||||
|
Repr::Simple(..) => None,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a reference to the inner error wrapped by this error (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// fn print_error(err: &Error) {
|
||||||
|
/// if let Some(inner_err) = err.get_ref() {
|
||||||
|
/// println!("Inner error: {:?}", inner_err);
|
||||||
|
/// } else {
|
||||||
|
/// println!("No inner error");
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// // Will print "No inner error".
|
||||||
|
/// print_error(&Error::last_os_error());
|
||||||
|
/// // Will print "Inner error: ...".
|
||||||
|
/// print_error(&Error::new(ErrorKind::Other, "oh no!"));
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn get_ref(&self) -> Option<&String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Simple(..) => None,
|
||||||
|
Repr::Custom(ref c) => Some(&c.error),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns a mutable reference to the inner error wrapped by this error
|
||||||
|
/// (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
/// use std::{error, fmt};
|
||||||
|
/// use std::fmt::Display;
|
||||||
|
///
|
||||||
|
/// #[derive(Debug)]
|
||||||
|
/// struct MyError {
|
||||||
|
/// v: String,
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// impl MyError {
|
||||||
|
/// fn new() -> MyError {
|
||||||
|
/// MyError {
|
||||||
|
/// v: "oh no!".to_string()
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn change_message(&mut self, new_message: &str) {
|
||||||
|
/// self.v = new_message.to_string();
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// impl error::Error for MyError {}
|
||||||
|
///
|
||||||
|
/// impl Display for MyError {
|
||||||
|
/// fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
/// write!(f, "MyError: {}", &self.v)
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn change_error(mut err: Error) -> Error {
|
||||||
|
/// if let Some(inner_err) = err.get_mut() {
|
||||||
|
/// inner_err.downcast_mut::<MyError>().unwrap().change_message("I've been changed!");
|
||||||
|
/// }
|
||||||
|
/// err
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn print_error(err: &Error) {
|
||||||
|
/// if let Some(inner_err) = err.get_ref() {
|
||||||
|
/// println!("Inner error: {}", inner_err);
|
||||||
|
/// } else {
|
||||||
|
/// println!("No inner error");
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// // Will print "No inner error".
|
||||||
|
/// print_error(&change_error(Error::last_os_error()));
|
||||||
|
/// // Will print "Inner error: ...".
|
||||||
|
/// print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn get_mut(&mut self) -> Option<&mut String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Simple(..) => None,
|
||||||
|
Repr::Custom(ref mut c) => Some(&mut c.error),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Consumes the `Error`, returning its inner error (if any).
|
||||||
|
///
|
||||||
|
/// If this `Error` was constructed via `new` then this function will
|
||||||
|
/// return `Some`, otherwise it will return `None`.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// fn print_error(err: Error) {
|
||||||
|
/// if let Some(inner_err) = err.into_inner() {
|
||||||
|
/// println!("Inner error: {}", inner_err);
|
||||||
|
/// } else {
|
||||||
|
/// println!("No inner error");
|
||||||
|
/// }
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// // Will print "No inner error".
|
||||||
|
/// print_error(Error::last_os_error());
|
||||||
|
/// // Will print "Inner error: ...".
|
||||||
|
/// print_error(Error::new(ErrorKind::Other, "oh no!"));
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn into_inner(self) -> Option<String> {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(..) => None,
|
||||||
|
Repr::Simple(..) => None,
|
||||||
|
Repr::Custom(c) => Some(c.error),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the corresponding `ErrorKind` for this error.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{Error, ErrorKind};
|
||||||
|
///
|
||||||
|
/// fn print_error(err: Error) {
|
||||||
|
/// println!("{:?}", err.kind());
|
||||||
|
/// }
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// // Will print "No inner error".
|
||||||
|
/// print_error(Error::last_os_error());
|
||||||
|
/// // Will print "Inner error: ...".
|
||||||
|
/// print_error(Error::new(ErrorKind::AddrInUse, "oh no!"));
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn kind(&self) -> ErrorKind {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(_code) => ErrorKind::Other,
|
||||||
|
Repr::Custom(ref c) => c.kind,
|
||||||
|
Repr::Simple(kind) => kind,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Repr {
|
||||||
|
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
match *self {
|
||||||
|
Repr::Os(code) => fmt
|
||||||
|
.debug_struct("Os")
|
||||||
|
.field("code", &code)
|
||||||
|
.finish(),
|
||||||
|
Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),
|
||||||
|
Repr::Simple(kind) => fmt.debug_tuple("Kind").field(&kind).finish(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Display for Error {
|
||||||
|
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
match self.repr {
|
||||||
|
Repr::Os(code) => {
|
||||||
|
write!(fmt, "os error {}", code)
|
||||||
|
}
|
||||||
|
Repr::Custom(ref c) => c.error.fmt(fmt),
|
||||||
|
Repr::Simple(kind) => write!(fmt, "{}", kind.as_str()),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn _assert_error_is_sync_send() {
|
||||||
|
fn _is_sync_send<T: Sync + Send>() {}
|
||||||
|
_is_sync_send::<Error>();
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod test {
|
||||||
|
use super::{Custom, Error, ErrorKind, Repr};
|
||||||
|
use crate::error;
|
||||||
|
use crate::fmt;
|
||||||
|
use crate::sys::decode_error_kind;
|
||||||
|
use crate::sys::os::error_string;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_debug_error() {
|
||||||
|
let code = 6;
|
||||||
|
let msg = error_string(code);
|
||||||
|
let kind = decode_error_kind(code);
|
||||||
|
let err = Error {
|
||||||
|
repr: Repr::Custom(box Custom {
|
||||||
|
kind: ErrorKind::InvalidInput,
|
||||||
|
error: box Error { repr: super::Repr::Os(code) },
|
||||||
|
}),
|
||||||
|
};
|
||||||
|
let expected = format!(
|
||||||
|
"Custom {{ \
|
||||||
|
kind: InvalidInput, \
|
||||||
|
error: Os {{ \
|
||||||
|
code: {:?}, \
|
||||||
|
kind: {:?}, \
|
||||||
|
message: {:?} \
|
||||||
|
}} \
|
||||||
|
}}",
|
||||||
|
code, kind, msg
|
||||||
|
);
|
||||||
|
assert_eq!(format!("{:?}", err), expected);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_downcasting() {
|
||||||
|
#[derive(Debug)]
|
||||||
|
struct TestError;
|
||||||
|
|
||||||
|
impl fmt::Display for TestError {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
f.write_str("asdf")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl error::Error for TestError {}
|
||||||
|
|
||||||
|
// we have to call all of these UFCS style right now since method
|
||||||
|
// resolution won't implicitly drop the Send+Sync bounds
|
||||||
|
let mut err = Error::new(ErrorKind::Other, TestError);
|
||||||
|
assert!(err.get_ref().unwrap().is::<TestError>());
|
||||||
|
assert_eq!("asdf", err.get_ref().unwrap().to_string());
|
||||||
|
assert!(err.get_mut().unwrap().is::<TestError>());
|
||||||
|
let extracted = err.into_inner().unwrap();
|
||||||
|
extracted.downcast::<TestError>().unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,378 @@
|
||||||
|
use core::cmp;
|
||||||
|
use core::fmt;
|
||||||
|
use crate::io::{
|
||||||
|
self, Error, ErrorKind, Initializer, Read, Seek, SeekFrom, Write,
|
||||||
|
};
|
||||||
|
#[cfg(feature = "collections")] use crate::io::BufRead;
|
||||||
|
use core::mem;
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
use collections::{
|
||||||
|
vec::Vec,
|
||||||
|
string::String,
|
||||||
|
};
|
||||||
|
#[cfg(feature = "alloc")]
|
||||||
|
use alloc::boxed::Box;
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
// Forwarding implementations
|
||||||
|
|
||||||
|
impl<R: Read + ?Sized> Read for &mut R {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
(**self).read(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn initializer(&self) -> Initializer {
|
||||||
|
(**self).initializer()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_to_end(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_to_string(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
(**self).read_exact(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<W: Write + ?Sized> Write for &mut W {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
(**self).write(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
(**self).flush()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
(**self).write_all(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
|
||||||
|
(**self).write_fmt(fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl<S: Seek + ?Sized> Seek for &mut S {
|
||||||
|
#[inline]
|
||||||
|
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
|
||||||
|
(**self).seek(pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(feature = "collections")]
|
||||||
|
impl<B: BufRead + ?Sized> BufRead for &mut B {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
(**self).fill_buf()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) {
|
||||||
|
(**self).consume(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_until(byte, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_line(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="alloc")]
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl<R: Read + ?Sized> Read for Box<R> {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
(**self).read(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_to_end(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_to_string(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
(**self).read_exact(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(feature="alloc")]
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl<W: Write + ?Sized> Write for Box<W> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
(**self).write(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
(**self).flush()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
(**self).write_all(buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_fmt(&mut self, fmt: fmt::Arguments<'_>) -> io::Result<()> {
|
||||||
|
(**self).write_fmt(fmt)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl<S: Seek + ?Sized> Seek for Box<S> {
|
||||||
|
#[inline]
|
||||||
|
fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {
|
||||||
|
(**self).seek(pos)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl<B: BufRead + ?Sized> BufRead for Box<B> {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
(**self).fill_buf()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) {
|
||||||
|
(**self).consume(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
(**self).read_until(byte, buf)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {
|
||||||
|
(**self).read_line(buf)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Used by panicking::default_hook
|
||||||
|
#[cfg(test)]
|
||||||
|
/// This impl is only used by printing logic, so any error returned is always
|
||||||
|
/// of kind `Other`, and should be ignored.
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl Write for Box<dyn (::realstd::io::Write) + Send> {
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
(**self).write(buf).map_err(|_| ErrorKind::Other.into())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
(**self).flush().map_err(|_| ErrorKind::Other.into())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// =============================================================================
|
||||||
|
// In-memory buffer implementations
|
||||||
|
|
||||||
|
/// Read is implemented for `&[u8]` by copying from the slice.
|
||||||
|
///
|
||||||
|
/// Note that reading updates the slice to point to the yet unread part.
|
||||||
|
/// The slice will be empty when EOF is reached.
|
||||||
|
impl Read for &[u8] {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
let amt = cmp::min(buf.len(), self.len());
|
||||||
|
let (a, b) = self.split_at(amt);
|
||||||
|
|
||||||
|
// First check if the amount of bytes we want to read is small:
|
||||||
|
// `copy_from_slice` will generally expand to a call to `memcpy`, and
|
||||||
|
// for a single byte the overhead is significant.
|
||||||
|
if amt == 1 {
|
||||||
|
buf[0] = a[0];
|
||||||
|
} else {
|
||||||
|
buf[..amt].copy_from_slice(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
*self = b;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn initializer(&self) -> Initializer {
|
||||||
|
Initializer::nop()
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
|
||||||
|
if buf.len() > self.len() {
|
||||||
|
return Err(Error::new(ErrorKind::UnexpectedEof, "failed to fill whole buffer"));
|
||||||
|
}
|
||||||
|
let (a, b) = self.split_at(buf.len());
|
||||||
|
|
||||||
|
// First check if the amount of bytes we want to read is small:
|
||||||
|
// `copy_from_slice` will generally expand to a call to `memcpy`, and
|
||||||
|
// for a single byte the overhead is significant.
|
||||||
|
if buf.len() == 1 {
|
||||||
|
buf[0] = a[0];
|
||||||
|
} else {
|
||||||
|
buf.copy_from_slice(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
*self = b;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
#[inline]
|
||||||
|
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
|
||||||
|
buf.extend_from_slice(*self);
|
||||||
|
let len = self.len();
|
||||||
|
*self = &self[len..];
|
||||||
|
Ok(len)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl BufRead for &[u8] {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
Ok(*self)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, amt: usize) {
|
||||||
|
*self = &self[amt..];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting
|
||||||
|
/// its data.
|
||||||
|
///
|
||||||
|
/// Note that writing updates the slice to point to the yet unwritten part.
|
||||||
|
/// The slice will be empty when it has been completely overwritten.
|
||||||
|
impl Write for &mut [u8] {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
|
||||||
|
let amt = cmp::min(data.len(), self.len());
|
||||||
|
let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
|
||||||
|
a.copy_from_slice(&data[..amt]);
|
||||||
|
*self = b;
|
||||||
|
Ok(amt)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, data: &[u8]) -> io::Result<()> {
|
||||||
|
if self.write(data)? == data.len() {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(Error::new(ErrorKind::WriteZero, "failed to write whole buffer"))
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write is implemented for `Vec<u8>` by appending to the vector.
|
||||||
|
/// The vector will grow as needed.
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl Write for Vec<u8> {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
self.extend_from_slice(buf);
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
|
||||||
|
self.extend_from_slice(buf);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use crate::io::prelude::*;
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_read_slice(b: &mut test::Bencher) {
|
||||||
|
let buf = [5; 1024];
|
||||||
|
let mut dst = [0; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut rd = &buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = rd.read(&mut dst);
|
||||||
|
test::black_box(&dst);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_write_slice(b: &mut test::Bencher) {
|
||||||
|
let mut buf = [0; 1024];
|
||||||
|
let src = [5; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut wr = &mut buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = wr.write_all(&src);
|
||||||
|
test::black_box(&wr);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_read_vec(b: &mut test::Bencher) {
|
||||||
|
let buf = vec![5; 1024];
|
||||||
|
let mut dst = [0; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut rd = &buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = rd.read(&mut dst);
|
||||||
|
test::black_box(&dst);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
#[bench]
|
||||||
|
fn bench_write_vec(b: &mut test::Bencher) {
|
||||||
|
let mut buf = Vec::with_capacity(1024);
|
||||||
|
let src = [5; 128];
|
||||||
|
|
||||||
|
b.iter(|| {
|
||||||
|
let mut wr = &mut buf[..];
|
||||||
|
for _ in 0..8 {
|
||||||
|
let _ = wr.write_all(&src);
|
||||||
|
test::black_box(&wr);
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,13 @@
|
||||||
|
//! The I/O Prelude
|
||||||
|
//!
|
||||||
|
//! The purpose of this module is to alleviate imports of many common I/O traits
|
||||||
|
//! by adding a glob import to the top of I/O heavy modules:
|
||||||
|
//!
|
||||||
|
//! ```
|
||||||
|
//! # #![allow(unused_imports)]
|
||||||
|
//! use std::io::prelude::*;
|
||||||
|
//! ```
|
||||||
|
|
||||||
|
|
||||||
|
pub use super::{Read, Seek, Write};
|
||||||
|
#[cfg(feature = "collections")] pub use super::BufRead;
|
||||||
|
|
@ -0,0 +1,269 @@
|
||||||
|
#![allow(missing_copy_implementations)]
|
||||||
|
|
||||||
|
use core::fmt;
|
||||||
|
use core::mem;
|
||||||
|
use crate::io::{self, ErrorKind, Initializer, Read, Write};
|
||||||
|
#[cfg(feature = "collections")] use crate::io::BufRead;
|
||||||
|
|
||||||
|
/// Copies the entire contents of a reader into a writer.
|
||||||
|
///
|
||||||
|
/// This function will continuously read data from `reader` and then
|
||||||
|
/// write it into `writer` in a streaming fashion until `reader`
|
||||||
|
/// returns EOF.
|
||||||
|
///
|
||||||
|
/// On success, the total number of bytes that were copied from
|
||||||
|
/// `reader` to `writer` is returned.
|
||||||
|
///
|
||||||
|
/// If you’re wanting to copy the contents of one file to another and you’re
|
||||||
|
/// working with filesystem paths, see the [`fs::copy`] function.
|
||||||
|
///
|
||||||
|
/// [`fs::copy`]: ../fs/fn.copy.html
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
///
|
||||||
|
/// This function will return an error immediately if any call to `read` or
|
||||||
|
/// `write` returns an error. All instances of `ErrorKind::Interrupted` are
|
||||||
|
/// handled by this function and the underlying operation is retried.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io;
|
||||||
|
///
|
||||||
|
/// fn main() -> io::Result<()> {
|
||||||
|
/// let mut reader: &[u8] = b"hello";
|
||||||
|
/// let mut writer: Vec<u8> = vec![];
|
||||||
|
///
|
||||||
|
/// io::copy(&mut reader, &mut writer)?;
|
||||||
|
///
|
||||||
|
/// assert_eq!(&b"hello"[..], &writer[..]);
|
||||||
|
/// Ok(())
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
pub fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> io::Result<u64>
|
||||||
|
where
|
||||||
|
R: Read,
|
||||||
|
W: Write,
|
||||||
|
{
|
||||||
|
let mut buf = unsafe {
|
||||||
|
#[allow(deprecated)]
|
||||||
|
let mut buf: [u8; super::DEFAULT_BUF_SIZE] = mem::uninitialized();
|
||||||
|
reader.initializer().initialize(&mut buf);
|
||||||
|
buf
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut written = 0;
|
||||||
|
loop {
|
||||||
|
let len = match reader.read(&mut buf) {
|
||||||
|
Ok(0) => return Ok(written),
|
||||||
|
Ok(len) => len,
|
||||||
|
Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
|
||||||
|
Err(e) => return Err(e),
|
||||||
|
};
|
||||||
|
writer.write_all(&buf[..len])?;
|
||||||
|
written += len as u64;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A reader which is always at EOF.
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`empty`]. Please see
|
||||||
|
/// the documentation of [`empty()`][`empty`] for more details.
|
||||||
|
///
|
||||||
|
/// [`empty`]: fn.empty.html
|
||||||
|
pub struct Empty {
|
||||||
|
_priv: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructs a new handle to an empty reader.
|
||||||
|
///
|
||||||
|
/// All reads from the returned reader will return [`Ok`]`(0)`.
|
||||||
|
///
|
||||||
|
/// [`Ok`]: ../result/enum.Result.html#variant.Ok
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// A slightly sad example of not reading anything into a buffer:
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{self, Read};
|
||||||
|
///
|
||||||
|
/// let mut buffer = String::new();
|
||||||
|
/// io::empty().read_to_string(&mut buffer).unwrap();
|
||||||
|
/// assert!(buffer.is_empty());
|
||||||
|
/// ```
|
||||||
|
pub fn empty() -> Empty {
|
||||||
|
Empty { _priv: () }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Read for Empty {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, _buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
Ok(0)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn initializer(&self) -> Initializer {
|
||||||
|
Initializer::nop()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(feature="collections")]
|
||||||
|
impl BufRead for Empty {
|
||||||
|
#[inline]
|
||||||
|
fn fill_buf(&mut self) -> io::Result<&[u8]> {
|
||||||
|
Ok(&[])
|
||||||
|
}
|
||||||
|
#[inline]
|
||||||
|
fn consume(&mut self, _n: usize) {}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Empty {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
f.pad("Empty { .. }")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A reader which yields one byte over and over and over and over and over and...
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`repeat`][repeat]. Please
|
||||||
|
/// see the documentation of `repeat()` for more details.
|
||||||
|
///
|
||||||
|
/// [repeat]: fn.repeat.html
|
||||||
|
pub struct Repeat {
|
||||||
|
byte: u8,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates an instance of a reader that infinitely repeats one byte.
|
||||||
|
///
|
||||||
|
/// All reads from this reader will succeed by filling the specified buffer with
|
||||||
|
/// the given byte.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```
|
||||||
|
/// use std::io::{self, Read};
|
||||||
|
///
|
||||||
|
/// let mut buffer = [0; 3];
|
||||||
|
/// io::repeat(0b101).read_exact(&mut buffer).unwrap();
|
||||||
|
/// assert_eq!(buffer, [0b101, 0b101, 0b101]);
|
||||||
|
/// ```
|
||||||
|
pub fn repeat(byte: u8) -> Repeat {
|
||||||
|
Repeat { byte }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Read for Repeat {
|
||||||
|
#[inline]
|
||||||
|
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
|
||||||
|
for slot in &mut *buf {
|
||||||
|
*slot = self.byte;
|
||||||
|
}
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn initializer(&self) -> Initializer {
|
||||||
|
Initializer::nop()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Repeat {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
f.pad("Repeat { .. }")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A writer which will move data into the void.
|
||||||
|
///
|
||||||
|
/// This struct is generally created by calling [`sink`][sink]. Please
|
||||||
|
/// see the documentation of `sink()` for more details.
|
||||||
|
///
|
||||||
|
/// [sink]: fn.sink.html
|
||||||
|
pub struct Sink {
|
||||||
|
_priv: (),
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Creates an instance of a writer which will successfully consume all data.
|
||||||
|
///
|
||||||
|
/// All calls to `write` on the returned instance will return `Ok(buf.len())`
|
||||||
|
/// and the contents of the buffer will not be inspected.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust
|
||||||
|
/// use std::io::{self, Write};
|
||||||
|
///
|
||||||
|
/// let buffer = vec![1, 2, 3, 5, 8];
|
||||||
|
/// let num_bytes = io::sink().write(&buffer).unwrap();
|
||||||
|
/// assert_eq!(num_bytes, 5);
|
||||||
|
/// ```
|
||||||
|
pub fn sink() -> Sink {
|
||||||
|
Sink { _priv: () }
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Write for Sink {
|
||||||
|
#[inline]
|
||||||
|
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
|
||||||
|
Ok(buf.len())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn flush(&mut self) -> io::Result<()> {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl fmt::Debug for Sink {
|
||||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
|
f.pad("Sink { .. }")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use crate::io::prelude::*;
|
||||||
|
use crate::io::{copy, empty, repeat, sink};
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn copy_copies() {
|
||||||
|
let mut r = repeat(0).take(4);
|
||||||
|
let mut w = sink();
|
||||||
|
assert_eq!(copy(&mut r, &mut w).unwrap(), 4);
|
||||||
|
|
||||||
|
let mut r = repeat(0).take(1 << 17);
|
||||||
|
assert_eq!(copy(&mut r as &mut dyn Read, &mut w as &mut dyn Write).unwrap(), 1 << 17);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn sink_sinks() {
|
||||||
|
let mut s = sink();
|
||||||
|
assert_eq!(s.write(&[]).unwrap(), 0);
|
||||||
|
assert_eq!(s.write(&[0]).unwrap(), 1);
|
||||||
|
assert_eq!(s.write(&[0; 1024]).unwrap(), 1024);
|
||||||
|
assert_eq!(s.by_ref().write(&[0; 1024]).unwrap(), 1024);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn empty_reads() {
|
||||||
|
let mut e = empty();
|
||||||
|
assert_eq!(e.read(&mut []).unwrap(), 0);
|
||||||
|
assert_eq!(e.read(&mut [0]).unwrap(), 0);
|
||||||
|
assert_eq!(e.read(&mut [0; 1024]).unwrap(), 0);
|
||||||
|
assert_eq!(e.by_ref().read(&mut [0; 1024]).unwrap(), 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn repeat_repeats() {
|
||||||
|
let mut r = repeat(4);
|
||||||
|
let mut b = [0; 1024];
|
||||||
|
assert_eq!(r.read(&mut b).unwrap(), 1024);
|
||||||
|
assert!(b.iter().all(|b| *b == 4));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn take_some_bytes() {
|
||||||
|
assert_eq!(repeat(4).take(100).bytes().count(), 100);
|
||||||
|
assert_eq!(repeat(4).take(100).bytes().next().unwrap().unwrap(), 4);
|
||||||
|
assert_eq!(repeat(1).take(10).chain(repeat(2).take(10)).bytes().count(), 20);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,51 @@
|
||||||
|
//! <p id="core_io-show-docblock"></p>
|
||||||
|
//! This is just a listing of the functionality available in this crate. See
|
||||||
|
//! the [std documentation](https://doc.rust-lang.org/nightly/std/io/index.html)
|
||||||
|
//! for a full description of the functionality.
|
||||||
|
#![allow(stable_features,unused_features)]
|
||||||
|
#![feature(question_mark,const_fn,copy_from_slice,try_from,str_internals,align_offset,slice_internals)]
|
||||||
|
#![cfg_attr(any(feature="alloc",feature="collections"),feature(alloc))]
|
||||||
|
#![cfg_attr(pattern_guards,feature(bind_by_move_pattern_guards,nll))]
|
||||||
|
#![cfg_attr(non_exhaustive,feature(non_exhaustive))]
|
||||||
|
#![cfg_attr(unicode,feature(str_char))]
|
||||||
|
#![cfg_attr(unicode,feature(unicode))]
|
||||||
|
#![no_std]
|
||||||
|
|
||||||
|
#[cfg_attr(feature="collections",macro_use)]
|
||||||
|
#[cfg_attr(feature="collections",allow(unused_imports))]
|
||||||
|
#[cfg(feature="collections")] extern crate alloc as collections;
|
||||||
|
#[cfg(feature="alloc")] extern crate alloc;
|
||||||
|
#[cfg(rustc_unicode)]
|
||||||
|
extern crate rustc_unicode;
|
||||||
|
#[cfg(std_unicode)]
|
||||||
|
extern crate std_unicode;
|
||||||
|
|
||||||
|
#[cfg(not(feature="collections"))]
|
||||||
|
pub type ErrorString = &'static str;
|
||||||
|
|
||||||
|
// Provide Box::new wrapper
|
||||||
|
#[cfg(not(feature="alloc"))]
|
||||||
|
struct FakeBox<T>(core::marker::PhantomData<T>);
|
||||||
|
#[cfg(not(feature="alloc"))]
|
||||||
|
impl<T> FakeBox<T> {
|
||||||
|
fn new(val: T) -> T {
|
||||||
|
val
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Needed for older compilers, to ignore vec!/format! macros in tests
|
||||||
|
#[cfg(not(feature="collections"))]
|
||||||
|
#[allow(unused)]
|
||||||
|
macro_rules! vec (
|
||||||
|
( $ elem : expr ; $ n : expr ) => { () };
|
||||||
|
( $ ( $ x : expr ) , * ) => { () };
|
||||||
|
( $ ( $ x : expr , ) * ) => { () };
|
||||||
|
);
|
||||||
|
#[cfg(not(feature="collections"))]
|
||||||
|
#[allow(unused)]
|
||||||
|
macro_rules! format {
|
||||||
|
( $ ( $ arg : tt ) * ) => { () };
|
||||||
|
}
|
||||||
|
|
||||||
|
mod io;
|
||||||
|
pub use io::*;
|
||||||
|
|
@ -19,6 +19,6 @@ in
|
||||||
XARGO_RUST_SRC = "${rustPlatform.rust.rustc.src}/src";
|
XARGO_RUST_SRC = "${rustPlatform.rust.rustc.src}/src";
|
||||||
|
|
||||||
shellHook = ''
|
shellHook = ''
|
||||||
echo "Run 'cargo xbuild --release -p experiments' to build."
|
echo "Run 'cargo xbuild --release -p ...' to build."
|
||||||
'';
|
'';
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,21 @@
|
||||||
|
[package]
|
||||||
|
name = "szl"
|
||||||
|
description = "Simple Zynq Loader"
|
||||||
|
version = "0.1.0"
|
||||||
|
authors = ["M-Labs"]
|
||||||
|
edition = "2018"
|
||||||
|
|
||||||
|
[features]
|
||||||
|
target_zc706 = ["libboard_zynq/target_zc706", "libsupport_zynq/target_zc706"]
|
||||||
|
default = ["target_zc706"]
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
log = "0.4"
|
||||||
|
byteorder = { version = "1.3", default-features = false }
|
||||||
|
core_io = { version = "0.1", features = ["collections"] }
|
||||||
|
|
||||||
|
libboard_zynq = { path = "../libboard_zynq" }
|
||||||
|
libsupport_zynq = { path = "../libsupport_zynq" }
|
||||||
|
libcortex_a9 = { path = "../libcortex_a9" }
|
||||||
|
libregister = { path = "../libregister" }
|
||||||
|
libconfig = { path = "../libconfig" }
|
||||||
|
|
@ -0,0 +1,22 @@
|
||||||
|
use std::env;
|
||||||
|
use std::fs::File;
|
||||||
|
use std::io::Write;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
println!("cargo:rerun-if-changed=build.rs");
|
||||||
|
let out = env::var("OUT_DIR").unwrap();
|
||||||
|
let out_dir = &PathBuf::from(&out);
|
||||||
|
|
||||||
|
// Put the linker script somewhere the linker can find it
|
||||||
|
File::create(out_dir.join("link.x"))
|
||||||
|
.unwrap()
|
||||||
|
.write_all(include_bytes!("link.x"))
|
||||||
|
.unwrap();
|
||||||
|
println!("cargo:rustc-link-search={}", out_dir.display());
|
||||||
|
|
||||||
|
// Only re-run the build script when link.x is changed,
|
||||||
|
// instead of when any part of the source code changes.
|
||||||
|
println!("cargo:rerun-if-changed=link.x");
|
||||||
|
}
|
||||||
|
|
||||||
|
|
@ -0,0 +1,69 @@
|
||||||
|
ENTRY(Reset);
|
||||||
|
|
||||||
|
MEMORY
|
||||||
|
{
|
||||||
|
/* 256 kB On-Chip Memory */
|
||||||
|
OCM : ORIGIN = 0, LENGTH = 0x30000
|
||||||
|
SDRAM : ORIGIN = 0x00100000, LENGTH = 0x1FF00000
|
||||||
|
OCM3 : ORIGIN = 0xFFFF0000, LENGTH = 0x10000
|
||||||
|
}
|
||||||
|
|
||||||
|
SECTIONS
|
||||||
|
{
|
||||||
|
.text :
|
||||||
|
{
|
||||||
|
KEEP(*(.text.exceptions));
|
||||||
|
*(.text.boot);
|
||||||
|
*(.text .text.*);
|
||||||
|
} > OCM
|
||||||
|
|
||||||
|
.rodata : ALIGN(4)
|
||||||
|
{
|
||||||
|
*(.rodata .rodata.*);
|
||||||
|
} > OCM
|
||||||
|
|
||||||
|
.data : ALIGN(4)
|
||||||
|
{
|
||||||
|
*(.data .data.*);
|
||||||
|
} > OCM
|
||||||
|
|
||||||
|
.heap (NOLOAD) : ALIGN(8)
|
||||||
|
{
|
||||||
|
__runtime_start = .;
|
||||||
|
. += 0x8000000;
|
||||||
|
__runtime_end = .;
|
||||||
|
__heap0_start = .;
|
||||||
|
. += 0x8000000;
|
||||||
|
__heap0_end = .;
|
||||||
|
} > SDRAM
|
||||||
|
|
||||||
|
.bss (NOLOAD) : ALIGN(4)
|
||||||
|
{
|
||||||
|
__bss_start = .;
|
||||||
|
*(.bss .bss.*);
|
||||||
|
. = ALIGN(4);
|
||||||
|
__bss_end = .;
|
||||||
|
} > OCM3
|
||||||
|
|
||||||
|
.stack1 (NOLOAD) : ALIGN(8)
|
||||||
|
{
|
||||||
|
__stack1_end = .;
|
||||||
|
. += 0x100;
|
||||||
|
__stack1_start = .;
|
||||||
|
} > OCM3
|
||||||
|
|
||||||
|
.stack0 (NOLOAD) : ALIGN(8)
|
||||||
|
{
|
||||||
|
__stack0_end = .;
|
||||||
|
. += 0x4000;
|
||||||
|
__stack0_start = .;
|
||||||
|
} > OCM3
|
||||||
|
|
||||||
|
/DISCARD/ :
|
||||||
|
{
|
||||||
|
/* Unused exception related info that only wastes space */
|
||||||
|
*(.ARM.exidx);
|
||||||
|
*(.ARM.exidx.*);
|
||||||
|
*(.ARM.extab.*);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,169 @@
|
||||||
|
#![no_std]
|
||||||
|
#![no_main]
|
||||||
|
|
||||||
|
extern crate alloc;
|
||||||
|
extern crate log;
|
||||||
|
|
||||||
|
mod netboot;
|
||||||
|
|
||||||
|
use alloc::rc::Rc;
|
||||||
|
use core::mem;
|
||||||
|
use core_io::{Read, Seek};
|
||||||
|
use libboard_zynq::{
|
||||||
|
self as zynq,
|
||||||
|
clocks::source::{ArmPll, ClockSource, IoPll},
|
||||||
|
clocks::Clocks,
|
||||||
|
logger, println, sdio, slcr,
|
||||||
|
timer::GlobalTimer,
|
||||||
|
};
|
||||||
|
use libconfig::{bootgen, sd_reader, Config};
|
||||||
|
use libcortex_a9::{
|
||||||
|
asm::{dsb, isb},
|
||||||
|
cache::{bpiall, dcciall, iciallu},
|
||||||
|
enable_fpu,
|
||||||
|
l2c::enable_l2_cache,
|
||||||
|
};
|
||||||
|
use libregister::RegisterR;
|
||||||
|
use libsupport_zynq::ram;
|
||||||
|
use log::info;
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
static mut __runtime_start: usize;
|
||||||
|
static mut __runtime_end: usize;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn boot_sd<File: Read + Seek>(
|
||||||
|
file: &mut Option<File>,
|
||||||
|
runtime_start: *mut u8,
|
||||||
|
runtime_max: usize,
|
||||||
|
) -> Result<(), ()> {
|
||||||
|
if file.is_none() {
|
||||||
|
log::error!("No bootgen file");
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
let mut file = file.as_mut().unwrap();
|
||||||
|
info!("Loading gateware");
|
||||||
|
bootgen::load_bitstream(&mut file).map_err(|e| log::error!("Cannot load gateware: {:?}", e))?;
|
||||||
|
|
||||||
|
info!("Loading runtime");
|
||||||
|
let runtime =
|
||||||
|
bootgen::get_runtime(&mut file).map_err(|e| log::error!("Cannot load runtime: {:?}", e))?;
|
||||||
|
|
||||||
|
if runtime.len() > runtime_max {
|
||||||
|
log::error!(
|
||||||
|
"Runtime binary too large, max {} but got {}",
|
||||||
|
runtime_max,
|
||||||
|
runtime.len()
|
||||||
|
);
|
||||||
|
}
|
||||||
|
unsafe {
|
||||||
|
let target = core::slice::from_raw_parts_mut(runtime_start, runtime.len());
|
||||||
|
target.copy_from_slice(&runtime);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[no_mangle]
|
||||||
|
pub fn main_core0() {
|
||||||
|
GlobalTimer::start();
|
||||||
|
enable_fpu();
|
||||||
|
logger::init().unwrap();
|
||||||
|
log::set_max_level(log::LevelFilter::Debug);
|
||||||
|
println!(
|
||||||
|
r#"
|
||||||
|
|
||||||
|
__________ __
|
||||||
|
/ ___/__ / / /
|
||||||
|
\__ \ / / / /
|
||||||
|
___/ / / /__/ /___
|
||||||
|
/____/ /____/_____/
|
||||||
|
|
||||||
|
(C) 2020 M-Labs
|
||||||
|
"#
|
||||||
|
);
|
||||||
|
info!("Simple Zynq Loader starting...");
|
||||||
|
enable_l2_cache();
|
||||||
|
|
||||||
|
const CPU_FREQ: u32 = 800_000_000;
|
||||||
|
|
||||||
|
ArmPll::setup(2 * CPU_FREQ);
|
||||||
|
Clocks::set_cpu_freq(CPU_FREQ);
|
||||||
|
IoPll::setup(1_000_000_000);
|
||||||
|
libboard_zynq::stdio::drop_uart(); // reinitialize UART after clocking change
|
||||||
|
let mut ddr = zynq::ddr::DdrRam::ddrram();
|
||||||
|
ram::init_alloc_core0();
|
||||||
|
|
||||||
|
let sdio0 = sdio::Sdio::sdio0(true);
|
||||||
|
let fs = if sdio0.is_card_inserted() {
|
||||||
|
info!("Card inserted. Mounting file system.");
|
||||||
|
let sd = sdio::sd_card::SdCard::from_sdio(sdio0).unwrap();
|
||||||
|
let reader = sd_reader::SdReader::new(sd);
|
||||||
|
reader
|
||||||
|
.mount_fatfs(sd_reader::PartitionEntry::Entry1)
|
||||||
|
.map(|v| Rc::new(v))
|
||||||
|
.ok()
|
||||||
|
} else {
|
||||||
|
info!("No SD card inserted.");
|
||||||
|
None
|
||||||
|
};
|
||||||
|
let fs_ref = fs.as_ref();
|
||||||
|
let root_dir = fs_ref.map(|fs| fs.root_dir());
|
||||||
|
let mut bootgen_file = root_dir.and_then(|root_dir| root_dir.open_file("/BOOT.BIN").ok());
|
||||||
|
let config = Config::from_fs(fs.clone());
|
||||||
|
|
||||||
|
unsafe {
|
||||||
|
let max_len =
|
||||||
|
&__runtime_end as *const usize as usize - &__runtime_start as *const usize as usize;
|
||||||
|
match slcr::RegisterBlock::unlocked(|slcr| slcr.boot_mode.read().boot_mode_pins()) {
|
||||||
|
slcr::BootModePins::Jtag => netboot::netboot(
|
||||||
|
&mut bootgen_file,
|
||||||
|
config,
|
||||||
|
&mut __runtime_start as *mut usize as *mut u8,
|
||||||
|
max_len,
|
||||||
|
),
|
||||||
|
slcr::BootModePins::SdCard => {
|
||||||
|
if boot_sd(
|
||||||
|
&mut bootgen_file,
|
||||||
|
&mut __runtime_start as *mut usize as *mut u8,
|
||||||
|
max_len,
|
||||||
|
)
|
||||||
|
.is_err()
|
||||||
|
{
|
||||||
|
log::error!("Error booting from SD card");
|
||||||
|
log::info!("Fall back on netboot");
|
||||||
|
netboot::netboot(
|
||||||
|
&mut bootgen_file,
|
||||||
|
config,
|
||||||
|
&mut __runtime_start as *mut usize as *mut u8,
|
||||||
|
max_len,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
v => {
|
||||||
|
panic!("Boot mode {:?} not supported", v);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
info!("Preparing for runtime execution");
|
||||||
|
// Flush data cache entries for all of L1 cache, including
|
||||||
|
// Memory/Instruction Synchronization Barriers
|
||||||
|
dcciall();
|
||||||
|
iciallu();
|
||||||
|
bpiall();
|
||||||
|
dsb();
|
||||||
|
isb();
|
||||||
|
|
||||||
|
// Start core0 only, for compatibility with FSBL.
|
||||||
|
info!("executing payload");
|
||||||
|
unsafe {
|
||||||
|
(mem::transmute::<*mut u8, fn()>(ddr.ptr::<u8>()))();
|
||||||
|
}
|
||||||
|
|
||||||
|
loop {}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[no_mangle]
|
||||||
|
pub fn main_core1() {
|
||||||
|
panic!("core1 started but should not have");
|
||||||
|
}
|
||||||
|
|
@ -0,0 +1,399 @@
|
||||||
|
use alloc::vec;
|
||||||
|
use alloc::vec::Vec;
|
||||||
|
use byteorder::{ByteOrder, NetworkEndian};
|
||||||
|
use core_io::{Read, Seek};
|
||||||
|
use libboard_zynq::{
|
||||||
|
devc,
|
||||||
|
eth::Eth,
|
||||||
|
smoltcp::{
|
||||||
|
self,
|
||||||
|
iface::{EthernetInterfaceBuilder, NeighborCache},
|
||||||
|
time::Instant,
|
||||||
|
wire::IpCidr,
|
||||||
|
},
|
||||||
|
timer::GlobalTimer,
|
||||||
|
};
|
||||||
|
use libconfig::{bootgen, net_settings, Config};
|
||||||
|
|
||||||
|
enum NetConnState {
|
||||||
|
WaitCommand,
|
||||||
|
FirmwareLength(usize, u8),
|
||||||
|
FirmwareDownload(usize, usize),
|
||||||
|
FirmwareWaitO,
|
||||||
|
FirmwareWaitK,
|
||||||
|
GatewareLength(usize, u8),
|
||||||
|
GatewareDownload(usize, usize),
|
||||||
|
GatewareWaitO,
|
||||||
|
GatewareWaitK,
|
||||||
|
}
|
||||||
|
|
||||||
|
struct NetConn {
|
||||||
|
state: NetConnState,
|
||||||
|
firmware_downloaded: bool,
|
||||||
|
gateware_downloaded: bool,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl NetConn {
|
||||||
|
pub fn new() -> NetConn {
|
||||||
|
NetConn {
|
||||||
|
state: NetConnState::WaitCommand,
|
||||||
|
firmware_downloaded: false,
|
||||||
|
gateware_downloaded: false,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn reset(&mut self) {
|
||||||
|
self.state = NetConnState::WaitCommand;
|
||||||
|
self.firmware_downloaded = false;
|
||||||
|
self.gateware_downloaded = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
fn input_partial<File: Read + Seek>(
|
||||||
|
&mut self,
|
||||||
|
bootgen_file: &mut Option<File>,
|
||||||
|
runtime_start: *mut u8,
|
||||||
|
runtime_max_len: usize,
|
||||||
|
buf: &[u8],
|
||||||
|
storage: &mut Vec<u8>,
|
||||||
|
mut boot_callback: impl FnMut(),
|
||||||
|
) -> Result<usize, ()> {
|
||||||
|
match self.state {
|
||||||
|
NetConnState::WaitCommand => match buf[0] {
|
||||||
|
b'F' => {
|
||||||
|
log::info!("Received firmware load command");
|
||||||
|
self.state = NetConnState::FirmwareLength(0, 0);
|
||||||
|
Ok(1)
|
||||||
|
}
|
||||||
|
b'G' => {
|
||||||
|
log::info!("Received gateware load command");
|
||||||
|
self.state = NetConnState::GatewareLength(0, 0);
|
||||||
|
storage.clear();
|
||||||
|
Ok(1)
|
||||||
|
}
|
||||||
|
b'B' => {
|
||||||
|
if !self.gateware_downloaded {
|
||||||
|
log::info!("Gateware not loaded via netboot");
|
||||||
|
if bootgen_file.is_none() {
|
||||||
|
log::error!("No bootgen file to load gateware");
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
log::info!("Attempting to load from SD card");
|
||||||
|
if let Err(e) = bootgen::load_bitstream(bootgen_file.as_mut().unwrap()) {
|
||||||
|
log::error!("Gateware load failed: {:?}", e);
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if self.firmware_downloaded {
|
||||||
|
log::info!("Received boot command");
|
||||||
|
boot_callback();
|
||||||
|
self.state = NetConnState::WaitCommand;
|
||||||
|
Ok(1)
|
||||||
|
} else {
|
||||||
|
log::error!("Received boot command, but no firmware downloaded");
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => {
|
||||||
|
log::error!("Received unknown netboot command: 0x{:02x}", buf[0]);
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
},
|
||||||
|
NetConnState::FirmwareLength(firmware_length, recv_bytes) => {
|
||||||
|
let firmware_length = (firmware_length << 8) | (buf[0] as usize);
|
||||||
|
let recv_bytes = recv_bytes + 1;
|
||||||
|
if recv_bytes == 4 {
|
||||||
|
if firmware_length > runtime_max_len {
|
||||||
|
log::error!(
|
||||||
|
"Runtime too large, maximum {} but requested {}",
|
||||||
|
runtime_max_len,
|
||||||
|
firmware_length
|
||||||
|
);
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
self.state = NetConnState::FirmwareDownload(firmware_length, 0);
|
||||||
|
storage.clear();
|
||||||
|
storage.reserve(firmware_length);
|
||||||
|
} else {
|
||||||
|
self.state = NetConnState::FirmwareLength(firmware_length, recv_bytes);
|
||||||
|
}
|
||||||
|
Ok(1)
|
||||||
|
}
|
||||||
|
NetConnState::FirmwareDownload(firmware_length, recv_bytes) => {
|
||||||
|
let max_length = firmware_length - recv_bytes;
|
||||||
|
let buf = if buf.len() > max_length {
|
||||||
|
&buf[..max_length]
|
||||||
|
} else {
|
||||||
|
&buf[..]
|
||||||
|
};
|
||||||
|
let length = buf.len();
|
||||||
|
|
||||||
|
storage.extend_from_slice(buf);
|
||||||
|
|
||||||
|
let recv_bytes = recv_bytes + length;
|
||||||
|
if recv_bytes == firmware_length {
|
||||||
|
self.state = NetConnState::FirmwareWaitO;
|
||||||
|
Ok(length)
|
||||||
|
} else {
|
||||||
|
self.state = NetConnState::FirmwareDownload(firmware_length, recv_bytes);
|
||||||
|
Ok(length)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
NetConnState::FirmwareWaitO => {
|
||||||
|
if buf[0] == b'O' {
|
||||||
|
self.state = NetConnState::FirmwareWaitK;
|
||||||
|
Ok(1)
|
||||||
|
} else {
|
||||||
|
log::error!("End-of-firmware confirmation failed");
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
NetConnState::FirmwareWaitK => {
|
||||||
|
if buf[0] == b'K' {
|
||||||
|
log::info!("Firmware successfully downloaded");
|
||||||
|
self.state = NetConnState::WaitCommand;
|
||||||
|
self.firmware_downloaded = true;
|
||||||
|
{
|
||||||
|
let dest = unsafe {
|
||||||
|
core::slice::from_raw_parts_mut(runtime_start, storage.len())
|
||||||
|
};
|
||||||
|
dest.copy_from_slice(storage);
|
||||||
|
}
|
||||||
|
Ok(1)
|
||||||
|
} else {
|
||||||
|
log::error!("End-of-firmware confirmation failed");
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
NetConnState::GatewareLength(gateware_length, recv_bytes) => {
|
||||||
|
let gateware_length = (gateware_length << 8) | (buf[0] as usize);
|
||||||
|
let recv_bytes = recv_bytes + 1;
|
||||||
|
if recv_bytes == 4 {
|
||||||
|
self.state = NetConnState::GatewareDownload(gateware_length, 0);
|
||||||
|
storage.clear();
|
||||||
|
storage.reserve_exact(gateware_length);
|
||||||
|
} else {
|
||||||
|
self.state = NetConnState::GatewareLength(gateware_length, recv_bytes);
|
||||||
|
}
|
||||||
|
Ok(1)
|
||||||
|
}
|
||||||
|
NetConnState::GatewareDownload(gateware_length, recv_bytes) => {
|
||||||
|
let max_length = gateware_length - recv_bytes;
|
||||||
|
let buf = if buf.len() > max_length {
|
||||||
|
&buf[..max_length]
|
||||||
|
} else {
|
||||||
|
&buf[..]
|
||||||
|
};
|
||||||
|
let length = buf.len();
|
||||||
|
|
||||||
|
storage.extend_from_slice(buf);
|
||||||
|
|
||||||
|
let recv_bytes = recv_bytes + length;
|
||||||
|
if recv_bytes == gateware_length {
|
||||||
|
self.state = NetConnState::GatewareWaitO;
|
||||||
|
Ok(length)
|
||||||
|
} else {
|
||||||
|
self.state = NetConnState::GatewareDownload(gateware_length, recv_bytes);
|
||||||
|
Ok(length)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
NetConnState::GatewareWaitO => {
|
||||||
|
if buf[0] == b'O' {
|
||||||
|
self.state = NetConnState::GatewareWaitK;
|
||||||
|
Ok(1)
|
||||||
|
} else {
|
||||||
|
log::error!("End-of-gateware confirmation failed");
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
NetConnState::GatewareWaitK => {
|
||||||
|
if buf[0] == b'K' {
|
||||||
|
log::info!("Preprocessing bitstream...");
|
||||||
|
// find sync word 0xFFFFFFFF AA995566
|
||||||
|
let sync_word: [u8; 8] = [0xFF, 0xFF, 0xFF, 0xFF, 0xAA, 0x99, 0x55, 0x66];
|
||||||
|
let mut i = 0;
|
||||||
|
let mut state = 0;
|
||||||
|
while i < storage.len() {
|
||||||
|
if storage[i] == sync_word[state] {
|
||||||
|
state += 1;
|
||||||
|
if state == sync_word.len() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// backtrack
|
||||||
|
// not very efficient but we only have 8 elements
|
||||||
|
'outer: while state > 0 {
|
||||||
|
state -= 1;
|
||||||
|
for j in 0..state {
|
||||||
|
if storage[i - j] != sync_word[state - j] {
|
||||||
|
continue 'outer;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
if state != sync_word.len() {
|
||||||
|
log::error!("Sync word not found in bitstream (corrupted?)");
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
// we need the sync word
|
||||||
|
// i was pointing to the last element in the sync sequence
|
||||||
|
i -= sync_word.len() - 1;
|
||||||
|
// // append no-op
|
||||||
|
// storage.extend_from_slice(&[0x20, 0, 0, 0]);
|
||||||
|
let bitstream = &mut storage[i..];
|
||||||
|
{
|
||||||
|
// swap endian
|
||||||
|
let swap = unsafe {
|
||||||
|
core::slice::from_raw_parts_mut(
|
||||||
|
bitstream.as_mut_ptr() as usize as *mut u32,
|
||||||
|
bitstream.len() / 4,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
NetworkEndian::from_slice_u32(swap);
|
||||||
|
}
|
||||||
|
unsafe {
|
||||||
|
// align to 64 bytes
|
||||||
|
let ptr = alloc::alloc::alloc(
|
||||||
|
alloc::alloc::Layout::from_size_align(bitstream.len(), 64).unwrap(),
|
||||||
|
);
|
||||||
|
let buffer = core::slice::from_raw_parts_mut(ptr, bitstream.len());
|
||||||
|
buffer.copy_from_slice(bitstream);
|
||||||
|
|
||||||
|
let mut devcfg = devc::DevC::new();
|
||||||
|
devcfg.enable();
|
||||||
|
let result = devcfg.program(&buffer);
|
||||||
|
core::ptr::drop_in_place(ptr);
|
||||||
|
if let Err(e) = result {
|
||||||
|
log::error!("Error during FPGA startup: {}", e);
|
||||||
|
return Err(());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
log::info!("Gateware successfully downloaded");
|
||||||
|
self.state = NetConnState::WaitCommand;
|
||||||
|
self.gateware_downloaded = true;
|
||||||
|
Ok(1)
|
||||||
|
} else {
|
||||||
|
log::info!("End-of-gateware confirmation failed");
|
||||||
|
Err(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn input<File: Read + Seek>(
|
||||||
|
&mut self,
|
||||||
|
bootgen_file: &mut Option<File>,
|
||||||
|
runtime_start: *mut u8,
|
||||||
|
runtime_max_len: usize,
|
||||||
|
buf: &[u8],
|
||||||
|
storage: &mut Vec<u8>,
|
||||||
|
mut boot_callback: impl FnMut(),
|
||||||
|
) -> Result<(), ()> {
|
||||||
|
let mut remaining = &buf[..];
|
||||||
|
while !remaining.is_empty() {
|
||||||
|
let read_cnt = self.input_partial(
|
||||||
|
bootgen_file,
|
||||||
|
runtime_start,
|
||||||
|
runtime_max_len,
|
||||||
|
remaining,
|
||||||
|
storage,
|
||||||
|
&mut boot_callback,
|
||||||
|
)?;
|
||||||
|
remaining = &remaining[read_cnt..];
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn netboot<File: Read + Seek>(
|
||||||
|
bootgen_file: &mut Option<File>,
|
||||||
|
cfg: Config,
|
||||||
|
runtime_start: *mut u8,
|
||||||
|
runtime_max_len: usize,
|
||||||
|
) {
|
||||||
|
log::info!("Preparing network for netboot");
|
||||||
|
let net_addresses = net_settings::get_adresses(&cfg);
|
||||||
|
log::info!("Network addresses: {}", net_addresses);
|
||||||
|
let eth = Eth::eth0(net_addresses.hardware_addr.0.clone());
|
||||||
|
let eth = eth.start_rx(8);
|
||||||
|
let mut eth = eth.start_tx(8);
|
||||||
|
|
||||||
|
let mut neighbor_map = [None; 2];
|
||||||
|
let neighbor_cache = NeighborCache::new(&mut neighbor_map[..]);
|
||||||
|
let mut ip_addrs = [IpCidr::new(net_addresses.ipv4_addr, 0)];
|
||||||
|
let mut interface = EthernetInterfaceBuilder::new(&mut eth)
|
||||||
|
.ethernet_addr(net_addresses.hardware_addr)
|
||||||
|
.ip_addrs(&mut ip_addrs[..])
|
||||||
|
.neighbor_cache(neighbor_cache)
|
||||||
|
.finalize();
|
||||||
|
|
||||||
|
let mut rx_storage = vec![0; 4096];
|
||||||
|
let mut tx_storage = vec![0; 128];
|
||||||
|
|
||||||
|
let mut socket_set_entries: [_; 1] = Default::default();
|
||||||
|
let mut sockets = smoltcp::socket::SocketSet::new(&mut socket_set_entries[..]);
|
||||||
|
|
||||||
|
let tcp_rx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut rx_storage[..]);
|
||||||
|
let tcp_tx_buffer = smoltcp::socket::TcpSocketBuffer::new(&mut tx_storage[..]);
|
||||||
|
let tcp_socket = smoltcp::socket::TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
|
||||||
|
let tcp_handle = sockets.add(tcp_socket);
|
||||||
|
|
||||||
|
let mut net_conn = NetConn::new();
|
||||||
|
let mut storage = Vec::new();
|
||||||
|
let mut boot_flag = false;
|
||||||
|
let timer = unsafe { GlobalTimer::get() };
|
||||||
|
|
||||||
|
log::info!("Waiting for connections...");
|
||||||
|
loop {
|
||||||
|
let timestamp = Instant::from_millis(timer.get_time().0 as i64);
|
||||||
|
{
|
||||||
|
let socket = &mut *sockets.get::<smoltcp::socket::TcpSocket>(tcp_handle);
|
||||||
|
|
||||||
|
if boot_flag {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
if !socket.is_open() {
|
||||||
|
socket.listen(4269).unwrap() // 0x10ad
|
||||||
|
}
|
||||||
|
|
||||||
|
if socket.may_recv() {
|
||||||
|
if socket
|
||||||
|
.recv(|data| {
|
||||||
|
(
|
||||||
|
data.len(),
|
||||||
|
net_conn
|
||||||
|
.input(
|
||||||
|
bootgen_file,
|
||||||
|
runtime_start,
|
||||||
|
runtime_max_len,
|
||||||
|
data,
|
||||||
|
&mut storage,
|
||||||
|
|| {
|
||||||
|
boot_flag = true;
|
||||||
|
},
|
||||||
|
)
|
||||||
|
.is_err(),
|
||||||
|
)
|
||||||
|
})
|
||||||
|
.unwrap()
|
||||||
|
{
|
||||||
|
net_conn.reset();
|
||||||
|
socket.close();
|
||||||
|
}
|
||||||
|
} else if socket.may_send() {
|
||||||
|
net_conn.reset();
|
||||||
|
socket.close();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
match interface.poll(&mut sockets, timestamp) {
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(smoltcp::Error::Unrecognized) => (),
|
||||||
|
Err(err) => log::error!("Network error: {}", err),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue