.gitlab-ci.yml

+image: "redoxos/redoxer"
+
+stages:
+    - build
+    - test
+
+cache:
+    paths:
+        - target/
+
+build:linux:
+    stage: build
+    script: cargo +nightly build --verbose
+
+build:redox:
+    stage: build
+    script: redoxer build --verbose
+
+test:linux:
+    stage: test
+    dependencies:
+        - build:linux
+    script: cargo +nightly test --verbose
+
+test:redox:
+    stage: test
+    dependencies:
+        - build:redox
+    script: redoxer test --verbose

Cargo.lock

-[root]
-name = "redoxfs"
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "aes"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+ "opaque-debug",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anstream"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+dependencies = [
+ "anstyle",
+ "once_cell",
+ "windows-sys",
+]
+
+[[package]]
+name = "argon2"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db4ce4441f99dbd377ca8a8f57b698c44d0d6e712d8329b5040da5a64aa1ce73"
+dependencies = [
+ "base64ct",
+ "blake2",
+]
+
+[[package]]
+name = "base64ct"
+version = "1.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "89e25b6adfb930f02d1981565a6e5d9c547ac15a96606256d3b59040e5cd4ca3"
+
+[[package]]
+name = "bitflags"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c8214115b7bf84099f1309324e63141d4c5d7cc26862f97a0a857dbefe165bd"
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cipher"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "deranged"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cfac68e08048ae1883171632c2aef3ebc555621ae56fbccce1cbf22dd7f058"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "endian-num"
 version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8f59926911ef34d1efb9ea1ee8ca78385df62ce700ccf2bcb149011bd226888"
+
+[[package]]
+name = "env_filter"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "186e05a59d4c50738528153b83b0b0194d3a29507dfec16eccd4b342903397d0"
 dependencies = [
- "fuse 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "redox_syscall 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
- "spin 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log",
+ "regex",
 ]
 
 [[package]]
-name = "fuse"
-version = "0.2.8"
+name = "env_logger"
+version = "0.11.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3716d7a920fb4fac5d84e9d4bce8ceb321e9414b4409da61b07b75c1e3d0697"
 dependencies = [
- "libc 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "thread-scoped 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)",
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
 ]
 
 [[package]]
-name = "kernel32-sys"
-version = "0.2.2"
+name = "fuser"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e697f6f62c20b6fad1ba0f84ae909f25971cf16e735273524e3977c94604cf8"
 dependencies = [
- "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "libc",
+ "log",
+ "memchr",
+ "page_size",
+ "pkg-config",
+ "smallvec",
+ "zerocopy",
 ]
 
 [[package]]
-name = "libc"
-version = "0.1.12"
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "73fea8450eea4bac3940448fb7ae50d91f034f941199fcd9d909a5a07aa455f0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasi 0.14.2+wasi-0.2.4",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "jiff"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c102670231191d07d37a35af3eb77f1f0dbf7a71be51a962dcd57ea607be7260"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cdde31a9d349f1b1f51a0b3714a5940ac022976f4b49485fc04be052b183b4c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
 
 [[package]]
 name = "libc"
-version = "0.2.29"
+version = "0.2.171"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c19937216e9d3aa9956d9bb8dfc0b0c8beb6058fc4f7a4dc4d850edf86a237d6"
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags",
+ "libc",
+ "redox_syscall",
+]
 
 [[package]]
 name = "log"
-version = "0.3.8"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "numtoa"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6aa2c4e539b869820a2b82e1aef6ff40aa85e65decdd5185e83fb4b1249cd00f"
+
+[[package]]
+name = "once_cell"
+version = "1.21.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75b0bedcc4fe52caa0e03d9f1151a323e4aa5e2d78ba3580400cd3c9e2bc4bc"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "page_size"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30d5b2194ed13191c1999ae0704b7839fb18384fa22e49b57eeaa97d79ce40da"
+dependencies = [
+ "libc",
+ "winapi",
+]
 
 [[package]]
 name = "pkg-config"
-version = "0.3.9"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.94"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+
+[[package]]
+name = "range-tree"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384c2842d4e069d5ccacf5fe1dca4ef8d07a5444329715f0fc3c61813502d4d1"
+
+[[package]]
+name = "redox-path"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436d45c2b6a5b159d43da708e62b25be3a4a3d5550d654b72216ade4c4bfd717"
+
+[[package]]
+name = "redox-scheme"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6143c4d307e1c99ac14f60b5b07b2dccaf9d17137f7cee4e4e29977dd8014a1b"
+dependencies = [
+ "libredox",
+ "redox_syscall",
+]
 
 [[package]]
 name = "redox_syscall"
-version = "0.1.29"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b8c0c260b63a8219631167be35e6a988e9554dbd323f8bd08439c8ed1302bd1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "redox_termios"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
+
+[[package]]
+name = "redoxfs"
+version = "0.6.10"
+dependencies = [
+ "aes",
+ "argon2",
+ "base64ct",
+ "endian-num",
+ "env_logger",
+ "fuser",
+ "getrandom 0.2.15",
+ "libc",
+ "libredox",
+ "log",
+ "range-tree",
+ "redox-path",
+ "redox-scheme",
+ "redox_syscall",
+ "seahash",
+ "termion",
+ "time",
+ "uuid",
+]
+
+[[package]]
+name = "regex"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
-name = "spin"
-version = "0.4.5"
+name = "seahash"
+version = "4.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "serde"
+version = "1.0.219"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+dependencies = [
+ "serde_derive",
+]
 
 [[package]]
-name = "thread-scoped"
-version = "1.0.2"
+name = "serde_derive"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "smallvec"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.100"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "termion"
+version = "4.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f359c854fbecc1ea65bc3683f1dcb2dce78b174a1ca7fda37acd1fff81df6ff"
+dependencies = [
+ "libc",
+ "libredox",
+ "numtoa",
+ "redox_termios",
+]
 
 [[package]]
 name = "time"
-version = "0.1.38"
+version = "0.3.41"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
+
+[[package]]
+name = "typenum"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 dependencies = [
- "kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.29 (registry+https://github.com/rust-lang/crates.io-index)",
- "redox_syscall 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
+ "getrandom 0.3.2",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "wasi"
+version = "0.14.2+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+dependencies = [
+ "wit-bindgen-rt",
 ]
 
 [[package]]
 name = "winapi"
-version = "0.2.8"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
-name = "winapi-build"
-version = "0.1.1"
+name = "windows_i686_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[metadata]
-"checksum fuse 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "adf08478eb39cff95e34daa7a2743a256d1c18388c0328d2f717e8ef748001f6"
-"checksum kernel32-sys 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
-"checksum libc 0.1.12 (registry+https://github.com/rust-lang/crates.io-index)" = "e32a70cf75e5846d53a673923498228bbec6a8624708a9ea5645f075d6276122"
-"checksum libc 0.2.29 (registry+https://github.com/rust-lang/crates.io-index)" = "8a014d9226c2cc402676fbe9ea2e15dd5222cd1dd57f576b5b283178c944a264"
-"checksum log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "880f77541efa6e5cc74e76910c9884d9859683118839d6a1dc3b11e63512565b"
-"checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
-"checksum redox_syscall 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)" = "3c9309631a35303bffb47e397198e3668cb544fe8834cd3da2a744441e70e524"
-"checksum spin 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "1d16a26e2b789f86aabddbe91cb82ee2e822beb8a59840d631941b625ef77e53"
-"checksum thread-scoped 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "bcbb6aa301e5d3b0b5ef639c9a9c7e2f1c944f177b460c04dc24c69b1fa2bd99"
-"checksum time 0.1.38 (registry+https://github.com/rust-lang/crates.io-index)" = "d5d788d3aa77bc0ef3e9621256885555368b47bd495c13dd2e7413c89f845520"
-"checksum winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)" = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
-"checksum winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "wit-bindgen-rt"
+version = "0.39.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
+dependencies = [
+ "bitflags",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]

Cargo.toml

 [package]
 name = "redoxfs"
 description = "The Redox Filesystem"
-repository = "https://github.com/redox-os/redoxfs"
-version = "0.1.2"
+repository = "https://gitlab.redox-os.org/redox-os/redoxfs"
+version = "0.6.10"
 license-file = "LICENSE"
 readme = "README.md"
 authors = ["Jeremy Soller <jackpot51@gmail.com>"]
+edition = "2021"
 
 [lib]
 name = "redoxfs"
@@ -13,16 +14,63 @@ path = "src/lib.rs"
 
 [[bin]]
 name = "redoxfs"
-path = "mount/main.rs"
+path = "src/bin/mount.rs"
+doc = false
+required-features = ["std"]
+
+[[bin]]
+name = "redoxfs-ar"
+path = "src/bin/ar.rs"
+doc = false
+required-features = ["std"]
 
 [[bin]]
 name = "redoxfs-mkfs"
-path = "mkfs/main.rs"
+path = "src/bin/mkfs.rs"
+doc = false
+required-features = ["std"]
 
 [dependencies]
-spin = "0.4"
-redox_syscall = "0.1"
+aes = { version = "=0.7.5", default-features = false }
+argon2 = { version = "0.4", default-features = false, features = ["alloc"] }
+base64ct = { version = "1", default-features = false }
+env_logger = { version = "0.11", optional = true }
+endian-num = "0.1"
+getrandom = { version = "0.2.5", optional = true }
+libc = "0.2"
+log = { version = "0.4.14", default-features = false, optional = true}
+redox_syscall = { version = "0.5" }
+range-tree = { version = "0.1", optional = true }
+seahash = { version = "4.1.0", default-features = false }
+termion = { version = "4", optional = true }
+uuid = { version = "1.4", default-features = false }
+redox-path = "0.3.0"
+libredox = { version = "0.1.3", optional = true }
+redox-scheme = {  version = "0.2.1", optional = true }
+
+[features]
+default = ["std", "log"]
+force-soft = [
+    "aes/force-soft"
+]
+std = [
+    "env_logger",
+    "fuser",
+    "getrandom",
+    "libc",
+    "libredox",
+    "range-tree",
+    "termion",
+    "time",
+    "uuid/v4",
+    "redox_syscall/std",
+    "redox-scheme"
+]
+
+[target.'cfg(not(target_os = "redox"))'.dependencies]
+fuser = { version = "0.14", optional = true }
+libc = { version = "0.2", optional = true }
+time = { version = "0.3", optional = true }
 
-[target.'cfg(unix)'.dependencies]
-fuse = "0.2"
-time = "0.1"
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] }

DESIGN.md

-# RedoxFS Design Document
-
-## Structures
-
-### Header
-The header is the entry point for the filesystem. When mounting a disk or image, it should be scanned for a block starting with the 8-byte signature, within the first megabyte:
-```rust
-"RedoxFS\0"
-```
-
-The header stores the filesystem version, disk identifier, disk size, root block pointer, and free block pointer.
-
-```rust
-#[repr(packed)]
-pub struct Header {
-    pub signature: [u8; 8],
-    pub version: u64,
-    pub uuid: [u8; 16],
-    pub size: u64,
-    pub root: u64,
-    pub free: u64,
-}
-```
-
-The root and free block pointers point to a Node that identifies
-
-### Node
-
-```rust
-#[repr(packed)]
-pub struct Node {
-    pub name: [u8; 256],
-    pub mode: u64,
-    pub next: u64,
-    pub extents: [Extent; 15],
-}
-```

Makefile

+UNAME := $(shell uname)
+
+ifeq ($(UNAME),Darwin)
+	FUMOUNT=umount
+else ifeq ($(UNAME),FreeBSD)
+	FUMOUNT=sudo umount
+else
+	# Detect which version of the fusermount binary is available.
+	ifneq (, $(shell which fusermount3))
+		FUMOUNT=fusermount3 -u
+	else
+		FUMOUNT=fusermount -u
+	endif
+endif
+
 image.bin:
-	dd if=/dev/zero of=image.bin bs=1M count=1024
 	cargo build --release --bin redoxfs-mkfs
+	dd if=/dev/zero of=image.bin bs=1048576 count=1024
 	target/release/redoxfs-mkfs image.bin
 
 mount: image.bin FORCE
@@ -10,12 +25,12 @@ mount: image.bin FORCE
 
 unmount: FORCE
 	sync
-	-fusermount -u image
+	-${FUMOUNT} image
 	rm -rf image
 
 clean: FORCE
 	sync
-	-fusermount -u image
+	-${FUMOUNT} image
 	rm -rf image image.bin
 	cargo clean
 

README.md

-# redoxfs
-The Redox Filesystem. Compatible with Redox and Linux.
+# RedoxFS
+
+This is the default filesystem of Redox OS inspired by [ZFS](https://docs.freebsd.org/en/books/handbook/zfs/) and adapted to a microkernel architecture.
+
+(It's a replacement for [TFS](https://gitlab.redox-os.org/redox-os/tfs))
+
+Current features:
+
+- Compatible with Redox and Linux (FUSE)
+- Copy-on-write
+- Data/metadata checksums
+- Transparent encryption
+- Standard Unix file attributes
+- File/directory size limit up to 193TiB (212TB)
+- File/directory quantity limit up to 4 billion per 193TiB (2^32 - 1 = 4294967295)
+- MIT licensed
+- Disk encryption fully supported by the Redox bootloader, letting it load the kernel off an encrypted partition.
+
+Being MIT licensed, RedoxFS can be bundled on GPL-licensed operating systems (Linux, for example).
+
+### How to mount a partition
+
+- Install RedoxFS
+
+```sh
+cargo install redoxfs
+```
+
+You can also build RedoxFS from this repository.
+
+- Configure your storage device to allow rootless usage
+
+If you are on Linux you need root permission to acess block devices (storage), but it's recommended to run RedoxFS as rootless.
+
+To do that you need to configure your storage device permission to your user with the following command:
+
+```sh
+sudo setfacl -m u:your-username:rw /path/to/disk
+```
+
+- Mount your RedoxFS partition
+
+```sh
+redoxfs /path/to/disk /path/to/mount
+```
 
-[![Travis Build Status](https://travis-ci.org/redox-os/redoxfs.svg?branch=master)](https://travis-ci.org/redox-os/redoxfs)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 [![crates.io](http://meritbadge.herokuapp.com/redoxfs)](https://crates.io/crates/redoxfs)
+[![docs.rs](https://docs.rs/redoxfs/badge.svg)](https://docs.rs/redoxfs)

fuzz/.gitignore

+target
+corpus
+artifacts
+coverage

fuzz/Cargo.lock

+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "aes"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+ "opaque-debug",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.86"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3d1d046238990b9cf5bcde22a3fb3584ee5cf65fb2765f454ed428c7a0063da"
+
+[[package]]
+name = "arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7d5a26814d8dcb93b0e5a0ff3c6d80a8843bafb21b39e8e18a6f05471870e110"
+dependencies = [
+ "derive_arbitrary",
+]
+
+[[package]]
+name = "argon2"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25df3c03f1040d0069fcd3907e24e36d59f9b6fa07ba49be0eb25a794f036ba7"
+dependencies = [
+ "base64ct",
+ "blake2",
+]
+
+[[package]]
+name = "atty"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
+
+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cc"
+version = "1.0.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96c51067fd44124faa7f870b4b1c969379ad32b2ba805aa959430ceaa384f695"
+dependencies = [
+ "jobserver",
+ "libc",
+ "once_cell",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "cfg_aliases"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+
+[[package]]
+name = "cipher"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ee52072ec15386f770805afd189a01c8841be8696bed250fa2f13c4c0d6dfb7"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "derive_arbitrary"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67e77553c4162a157adbf834ebae5b415acbecbeafc7a74b0e886657506a7611"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "endian-num"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ad847bb2094f110bbdd6fa564894ca4556fd978958e93985420d680d3cb6d14"
+
+[[package]]
+name = "env_logger"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
+dependencies = [
+ "atty",
+ "humantime",
+ "log",
+ "regex",
+ "termcolor",
+]
+
+[[package]]
+name = "errno"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "534c5cf6194dfab3db3242765c03bbe257cf92f22b38f6bc0c58d59108a820ba"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fc0510504f03c51ada170672ac806f1f105a88aa97a5281117e1ddc3368e51a"
+
+[[package]]
+name = "fuser"
+version = "0.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5910691a0ececcc6eba8bb14029025c2d123e96a53db1533f6a4602861a5aaf7"
+dependencies = [
+ "libc",
+ "log",
+ "memchr",
+ "page_size",
+ "pkg-config",
+ "smallvec",
+ "users",
+ "zerocopy",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi 0.11.0+wasi-snapshot-preview1",
+]
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "humantime"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+
+[[package]]
+name = "jobserver"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2b099aaa34a9751c5bf0878add70444e1ed2dd73f347be99003d4577277de6e"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.155"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
+[[package]]
+name = "libredox"
+version = "0.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3af92c55d7d839293953fcd0fda5ecfe93297cfde6ffbdec13b41d99c0ba6607"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+ "redox_syscall 0.4.1",
+]
+
+[[package]]
+name = "libredox"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+dependencies = [
+ "bitflags 2.5.0",
+ "libc",
+ "redox_syscall 0.5.2",
+]
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+
+[[package]]
+name = "log"
+version = "0.4.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "nix"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
+dependencies = [
+ "bitflags 2.5.0",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
+[[package]]
+name = "numtoa"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"
+
+[[package]]
+name = "once_cell"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "page_size"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eebde548fbbf1ea81a99b128872779c437752fb99f217c45245e1a61dcd9edcd"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "pkg-config"
+version = "0.3.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22244ce15aa966053a896d1accb3a6e68469b97c7f33f284b99f0d576879fc23"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.36"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "range-tree"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384c2842d4e069d5ccacf5fe1dca4ef8d07a5444329715f0fc3c61813502d4d1"
+
+[[package]]
+name = "redox-path"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "436d45c2b6a5b159d43da708e62b25be3a4a3d5550d654b72216ade4c4bfd717"
+
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c82cf8cff14456045f55ec4241383baeff27af886adb72ffb2162f99911de0fd"
+dependencies = [
+ "bitflags 2.5.0",
+]
+
+[[package]]
+name = "redox_termios"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20145670ba436b55d91fc92d25e71160fbfbdd57831631c8d7d36377a476f1cb"
+
+[[package]]
+name = "redoxfs"
+version = "0.6.4"
+dependencies = [
+ "aes",
+ "argon2",
+ "base64ct",
+ "endian-num",
+ "env_logger",
+ "fuser",
+ "getrandom",
+ "libc",
+ "libredox 0.1.3",
+ "log",
+ "range-tree",
+ "redox-path",
+ "redox_syscall 0.5.2",
+ "seahash",
+ "termion",
+ "time",
+ "uuid",
+]
+
+[[package]]
+name = "redoxfs-fuzz"
+version = "0.0.0"
+dependencies = [
+ "anyhow",
+ "arbitrary",
+ "fuser",
+ "libfuzzer-sys",
+ "nix",
+ "redoxfs",
+ "tempfile",
+]
+
+[[package]]
+name = "regex"
+version = "1.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+
+[[package]]
+name = "rustix"
+version = "0.38.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
+dependencies = [
+ "bitflags 2.5.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
+[[package]]
+name = "seahash"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b"
+
+[[package]]
+name = "smallvec"
+version = "1.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+
+[[package]]
+name = "subtle"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
+
+[[package]]
+name = "syn"
+version = "2.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c42f3f41a2de00b01c0aaad383c5a45241efc8b2d1eda5661812fda5f3cdcff5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tempfile"
+version = "3.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
+dependencies = [
+ "cfg-if",
+ "fastrand",
+ "rustix",
+ "windows-sys",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "termion"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4648c7def6f2043b2568617b9f9b75eae88ca185dbc1f1fda30e95a85d49d7d"
+dependencies = [
+ "libc",
+ "libredox 0.0.2",
+ "numtoa",
+ "redox_termios",
+]
+
+[[package]]
+name = "time"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
+dependencies = [
+ "libc",
+ "wasi 0.10.0+wasi-snapshot-preview1",
+ "winapi",
+]
+
+[[package]]
+name = "typenum"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "users"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24cc0f6d6f267b73e5a2cadf007ba8f9bc39c6a6f9666f8cf25ea809a153b032"
+dependencies = [
+ "libc",
+ "log",
+]
+
+[[package]]
+name = "uuid"
+version = "1.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+dependencies = [
+ "getrandom",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+
+[[package]]
+name = "wasi"
+version = "0.10.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+
+[[package]]
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
+
+[[package]]
+name = "zerocopy"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "854e949ac82d619ee9a14c66a1b674ac730422372ccb759ce0c39cabcf2bf8e6"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.6.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "125139de3f6b9d625c39e2efdd73d41bdac468ccd556556440e322be0e1bbd91"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]

fuzz/Cargo.toml

+[package]
+name = "redoxfs-fuzz"
+version = "0.0.0"
+publish = false
+edition = "2021"
+
+[features]
+default = []
+log = []
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+anyhow = "1.0.86"
+arbitrary = { version = "1.3.2", features = ["derive"] }
+fuser = { version = "0.12.0" }
+libfuzzer-sys = "0.4"
+nix = { version = "0.29.0", features = ["fs"] }
+tempfile = "3.10.1"
+
+[dependencies.redoxfs]
+path = ".."
+
+[[bin]]
+name = "fuse_fuzz_target"
+path = "fuzz_targets/fuse_fuzz_target.rs"
+test = false
+doc = false
+bench = false

fuzz/fuzz_targets/fuse_fuzz_target.rs

+//! Fuzzer that exercises random file system operations against a FUSE-mounted redoxfs.
+
+#![no_main]
+
+use anyhow::{ensure, Result};
+use fuser;
+use libfuzzer_sys::{arbitrary::Arbitrary, fuzz_target, Corpus};
+use nix::sys::statvfs::statvfs;
+use std::{
+    fs::{self, File, FileTimes, OpenOptions},
+    io::{Read, Seek, SeekFrom, Write},
+    os::unix::fs::{self as unix_fs, PermissionsExt},
+    path::{Path, PathBuf},
+    thread,
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+use tempfile;
+
+use redoxfs::{mount::fuse::Fuse, DiskSparse, FileSystem};
+
+/// Maximum size for files and buffers. Chosen arbitrarily with fuzzing performance in mind.
+const MAX_SIZE: u64 = 10_000_000;
+/// Limit on the number of remounts in a single test case. Chosen arbitrarily with fuzzing
+/// performance in mind: remounts are costly.
+const MAX_MOUNT_SEQUENCES: usize = 3;
+
+/// An operation to be performed by the fuzzer.
+#[derive(Arbitrary, Clone, Debug)]
+enum Operation {
+    Chown {
+        path: PathBuf,
+        uid: Option<u32>,
+        gid: Option<u32>,
+    },
+    CreateDir {
+        path: PathBuf,
+    },
+    HardLink {
+        original: PathBuf,
+        link: PathBuf,
+    },
+    Metadata {
+        path: PathBuf,
+    },
+    Read {
+        path: PathBuf,
+    },
+    ReadDir {
+        path: PathBuf,
+    },
+    ReadLink {
+        path: PathBuf,
+    },
+    RemoveDir {
+        path: PathBuf,
+    },
+    RemoveFile {
+        path: PathBuf,
+    },
+    Rename {
+        from: PathBuf,
+        to: PathBuf,
+    },
+    SeekRead {
+        path: PathBuf,
+        seek_pos: u64,
+        buf_size: usize,
+    },
+    SeekWrite {
+        path: PathBuf,
+        seek_pos: u64,
+        buf_size: usize,
+    },
+    SetLen {
+        path: PathBuf,
+        size: u64,
+    },
+    SetPermissions {
+        path: PathBuf,
+        readonly: Option<bool>,
+        mode: Option<u32>,
+    },
+    SetTimes {
+        path: PathBuf,
+        accessed_since_epoch: Option<Duration>,
+        modified_since_epoch: Option<Duration>,
+    },
+    Statvfs {},
+    SymLink {
+        original: PathBuf,
+        link: PathBuf,
+    },
+    Write {
+        path: PathBuf,
+        buf_size: usize,
+    },
+}
+
+/// Parameters for mounting the file system and operations to be performed afterwards.
+#[derive(Arbitrary, Clone, Debug)]
+struct MountSequence {
+    squash: bool,
+    operations: Vec<Operation>,
+}
+
+/// The whole input to a single fuzzer invocation.
+#[derive(Arbitrary, Clone, Debug)]
+struct TestCase {
+    disk_size: u64,
+    reserved_size: u64,
+    mount_sequences: Vec<MountSequence>,
+}
+
+/// Creates the disk for backing the Redoxfs.
+fn create_disk(temp_path: &Path, disk_size: u64) -> DiskSparse {
+    let disk_path = temp_path.join("disk.img");
+    DiskSparse::create(disk_path, disk_size).unwrap()
+}
+
+/// Creates an empty Redoxfs.
+fn create_redoxfs(disk: DiskSparse, reserved_size: u64) -> bool {
+    let password = None;
+    let reserved = vec![0; reserved_size as usize];
+    let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
+    FileSystem::create_reserved(
+        disk,
+        password,
+        &reserved,
+        ctime.as_secs(),
+        ctime.subsec_nanos(),
+    )
+    .is_ok()
+}
+
+/// Mounts an existing Redoxfs, runs the callback and performs the unmount.
+fn with_redoxfs_mount<F>(temp_path: &Path, disk: DiskSparse, squash: bool, callback: F)
+where
+    F: FnOnce(&Path) + Send + 'static,
+{
+    let password = None;
+    let block = None;
+    let mut fs = FileSystem::open(disk, password, block, squash).unwrap();
+
+    let mount_path = temp_path.join("mount");
+    fs::create_dir_all(&mount_path).unwrap();
+    let mut session = fuser::Session::new(Fuse { fs: &mut fs }, &mount_path, &[]).unwrap();
+    let mut unmounter = session.unmount_callable();
+
+    let join_handle = thread::spawn(move || {
+        callback(&mount_path);
+        unmounter.unmount().unwrap();
+    });
+
+    session.run().unwrap();
+    join_handle.join().unwrap();
+}
+
+fn get_path_within_fs(fs_path: &Path, path_to_add: &Path) -> Result<PathBuf> {
+    ensure!(path_to_add.is_relative());
+    ensure!(path_to_add
+        .components()
+        .all(|c| c != std::path::Component::ParentDir));
+    Ok(fs_path.join(path_to_add))
+}
+
+fn do_operation(fs_path: &Path, op: &Operation) -> Result<()> {
+    match op {
+        Operation::Chown { path, uid, gid } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            unix_fs::chown(path, *uid, *gid)?;
+        }
+        Operation::CreateDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::create_dir(path)?;
+        }
+        Operation::HardLink { original, link } => {
+            let original = get_path_within_fs(fs_path, original)?;
+            let link = get_path_within_fs(fs_path, link)?;
+            fs::hard_link(original, link)?;
+        }
+        Operation::Metadata { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::metadata(path)?;
+        }
+        Operation::Read { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::read(path)?;
+        }
+        Operation::ReadDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let _ = fs::read_dir(path)?.count();
+        }
+        Operation::ReadLink { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::read_link(path)?;
+        }
+        Operation::RemoveDir { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::remove_dir(path)?;
+        }
+        Operation::RemoveFile { path } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            fs::remove_file(path)?;
+        }
+        Operation::Rename { from, to } => {
+            let from = get_path_within_fs(fs_path, from)?;
+            let to = get_path_within_fs(fs_path, to)?;
+            fs::rename(from, to)?;
+        }
+        Operation::SeekRead {
+            path,
+            seek_pos,
+            buf_size,
+        } => {
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let mut file = File::open(path)?;
+            file.seek(SeekFrom::Start(*seek_pos))?;
+            let mut buf = vec![0; *buf_size];
+            file.read(&mut buf)?;
+        }
+        Operation::SeekWrite {
+            path,
+            seek_pos,
+            buf_size,
+        } => {
+            ensure!(*seek_pos <= MAX_SIZE);
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let mut file = OpenOptions::new().write(true).open(path)?;
+            file.seek(SeekFrom::Start(*seek_pos))?;
+            let buf = vec![0; *buf_size];
+            file.write(&buf)?;
+        }
+        Operation::SetLen { path, size } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let file = OpenOptions::new().write(true).open(path)?;
+            file.set_len(*size)?;
+        }
+        Operation::SetPermissions {
+            path,
+            readonly,
+            mode,
+        } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let metadata = fs::metadata(&path)?;
+            let mut perms = metadata.permissions();
+            if let Some(readonly) = readonly {
+                perms.set_readonly(*readonly);
+            }
+            if let Some(mode) = mode {
+                perms.set_mode(*mode);
+            }
+            fs::set_permissions(path, perms)?;
+        }
+        Operation::SetTimes {
+            path,
+            accessed_since_epoch,
+            modified_since_epoch,
+        } => {
+            let path = get_path_within_fs(fs_path, path)?;
+            let file = File::options().write(true).open(path)?;
+            let mut times = FileTimes::new();
+            if let Some(accessed_since_epoch) = accessed_since_epoch {
+                if let Some(accessed) = UNIX_EPOCH.checked_add(*accessed_since_epoch) {
+                    times = times.set_accessed(accessed);
+                }
+            }
+            if let Some(modified_since_epoch) = modified_since_epoch {
+                if let Some(modified) = UNIX_EPOCH.checked_add(*modified_since_epoch) {
+                    times = times.set_modified(modified);
+                }
+            }
+            file.set_times(times)?;
+        }
+        Operation::Statvfs {} => {
+            statvfs(fs_path)?;
+        }
+        Operation::SymLink { original, link } => {
+            let original = get_path_within_fs(fs_path, original)?;
+            let link = get_path_within_fs(fs_path, link)?;
+            unix_fs::symlink(original, link)?;
+        }
+        Operation::Write { path, buf_size } => {
+            ensure!(*buf_size as u64 <= MAX_SIZE);
+            let path = get_path_within_fs(fs_path, path)?;
+            let buf = vec![0; *buf_size];
+            fs::write(path, &buf)?;
+        }
+    }
+    Ok(())
+}
+
+fuzz_target!(|test_case: TestCase| -> Corpus {
+    if test_case.disk_size > MAX_SIZE
+        || test_case.reserved_size > MAX_SIZE
+        || test_case.mount_sequences.len() > MAX_MOUNT_SEQUENCES
+    {
+        return Corpus::Reject;
+    }
+
+    let temp_dir = tempfile::Builder::new()
+        .prefix("fuse_fuzz_target")
+        .tempdir()
+        .unwrap();
+
+    #[cfg(feature = "log")]
+    eprintln!("create fs");
+    let disk = create_disk(temp_dir.path(), test_case.disk_size);
+    if !create_redoxfs(disk, test_case.reserved_size) {
+        // File system creation failed (e.g., due to insufficient space) so we bail out, still
+        // exercising this code path is useful.
+        return Corpus::Keep;
+    }
+
+    for mount_seq in test_case.mount_sequences.iter() {
+        #[cfg(feature = "log")]
+        eprintln!("mount fs");
+
+        let disk = create_disk(temp_dir.path(), test_case.disk_size);
+        let operations = mount_seq.operations.clone();
+        with_redoxfs_mount(temp_dir.path(), disk, mount_seq.squash, move |fs_path| {
+            for operation in operations.iter() {
+                #[cfg(feature = "log")]
+                eprintln!("do operation {operation:?}");
+
+                let _result = do_operation(fs_path, operation);
+
+                #[cfg(feature = "log")]
+                eprintln!("operation result {:?}", _result.err());
+            }
+        });
+
+        #[cfg(feature = "log")]
+        eprintln!("unmounted fs");
+    }
+    Corpus::Keep
+});

mkfs/image.rs

-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
-
-use redoxfs::Disk;
-use syscall::error::{Error, Result, EIO};
-
-macro_rules! try_disk {
-    ($expr:expr) => (match $expr {
-        Ok(val) => val,
-        Err(err) => {
-            println!("Disk I/O Error: {}", err);
-            return Err(Error::new(EIO));
-        }
-    })
-}
-
-pub struct Image {
-    file: File
-}
-
-impl Image {
-    pub fn open(path: &str) -> Result<Image> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).open(path));
-        Ok(Image {
-            file: file
-        })
-    }
-}
-
-impl Disk for Image {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * 512)));
-        let count = try_disk!(self.file.read(buffer));
-        Ok(count)
-    }
-
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * 512)));
-        let count = try_disk!(self.file.write(buffer));
-        Ok(count)
-    }
-
-    fn size(&mut self) -> Result<u64> {
-        let size = try_disk!(self.file.seek(SeekFrom::End(0)));
-        Ok(size)
-    }
-}

mkfs/main.rs

-#![deny(warnings)]
-
-extern crate redoxfs;
-extern crate syscall;
-
-use std::{env, process, str, time};
-
-use redoxfs::FileSystem;
-
-use image::Image;
-
-pub mod image;
-
-fn main() {
-    let mut args = env::args();
-    if let Some(path) = args.nth(1) {
-        let ctime = time::SystemTime::now().duration_since(time::UNIX_EPOCH).unwrap();
-
-        //Open an existing image
-        match Image::open(&path) {
-            Ok(disk) => match FileSystem::create(Box::new(disk), ctime.as_secs(), ctime.subsec_nanos()) {
-                Ok(filesystem) => {
-                    println!("redoxfs-mkfs: created filesystem on {}, size {} MB", path, filesystem.header.1.size/1024/1024);
-                },
-                Err(err) => {
-                    println!("redoxfs-mkfs: failed to create filesystem on {}: {}", path, err);
-                    process::exit(1);
-                }
-            },
-            Err(err) => {
-                println!("redoxfs-mkfs: failed to open image {}: {}", path, err);
-                process::exit(1);
-            }
-        }
-    } else {
-        println!("redoxfs-mkfs: no disk image provided");
-        println!("redoxfs-mkfs [disk]");
-        process::exit(1);
-    }
-}

mount/cache/linked_hash_map.rs

-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A HashMap wrapper that holds key-value pairs in insertion order.
-//!
-//! # Examples
-//!
-//! ```
-//! use linked_hash_map::LinkedHashMap;
-//!
-//! let mut map = LinkedHashMap::new();
-//! map.insert(2, 20);
-//! map.insert(1, 10);
-//! map.insert(3, 30);
-//! assert_eq!(map[&1], 10);
-//! assert_eq!(map[&2], 20);
-//! assert_eq!(map[&3], 30);
-//!
-//! let items: Vec<(i32, i32)> = map.iter().map(|t| (*t.0, *t.1)).collect();
-//! assert_eq!(items, [(2, 20), (1, 10), (3, 30)]);
-//! ```
-
-#![forbid(missing_docs)]
-#![cfg_attr(feature = "nightly", feature(hashmap_public_hasher))]
-#![cfg_attr(all(feature = "nightly", test), feature(test))]
-
-use std::borrow::Borrow;
-use std::cmp::Ordering;
-use std::collections::hash_map::{self, HashMap};
-use std::fmt;
-use std::hash::{BuildHasher, Hash, Hasher};
-use std::iter;
-use std::marker;
-use std::mem;
-use std::ops::{Index, IndexMut};
-use std::ptr;
-
-struct KeyRef<K> { k: *const K }
-
-struct LinkedHashMapEntry<K, V> {
-    next: *mut LinkedHashMapEntry<K, V>,
-    prev: *mut LinkedHashMapEntry<K, V>,
-    key: K,
-    value: V,
-}
-
-/// A linked hash map.
-pub struct LinkedHashMap<K, V, S = hash_map::RandomState> {
-    map: HashMap<KeyRef<K>, Box<LinkedHashMapEntry<K, V>>, S>,
-    head: *mut LinkedHashMapEntry<K, V>,
-    free: *mut LinkedHashMapEntry<K, V>,
-}
-
-impl<K: Hash> Hash for KeyRef<K> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        unsafe { (*self.k).hash(state) }
-    }
-}
-
-impl<K: PartialEq> PartialEq for KeyRef<K> {
-    fn eq(&self, other: &Self) -> bool {
-        unsafe{ (*self.k).eq(&*other.k) }
-    }
-}
-
-impl<K: Eq> Eq for KeyRef<K> {}
-
-// This type exists only to support borrowing `KeyRef`s, which cannot be borrowed to `Q` directly
-// due to conflicting implementations of `Borrow`. The layout of `&Qey<Q>` must be identical to
-// `&Q` in order to support transmuting in the `Qey::from_ref` method.
-#[derive(Hash, PartialEq, Eq)]
-struct Qey<Q: ?Sized>(Q);
-
-impl<Q: ?Sized> Qey<Q> {
-    fn from_ref(q: &Q) -> &Self { unsafe { mem::transmute(q) } }
-}
-
-impl<K, Q: ?Sized> Borrow<Qey<Q>> for KeyRef<K> where K: Borrow<Q> {
-    fn borrow(&self) -> &Qey<Q> {
-        Qey::from_ref(unsafe { (*self.k).borrow() })
-    }
-}
-
-impl<K, V> LinkedHashMapEntry<K, V> {
-    fn new(k: K, v: V) -> Self {
-        LinkedHashMapEntry {
-            key: k,
-            value: v,
-            next: ptr::null_mut(),
-            prev: ptr::null_mut(),
-        }
-    }
-}
-
-unsafe fn drop_empty_entry_box<K, V>(the_box: *mut LinkedHashMapEntry<K, V>) {
-    // Prevent compiler from trying to drop the un-initialized key and values in the node.
-    let LinkedHashMapEntry { key, value, .. } = *Box::from_raw(the_box);
-    mem::forget(key);
-    mem::forget(value);
-}
-
-impl<K: Hash + Eq, V> LinkedHashMap<K, V> {
-    /// Creates a linked hash map.
-    pub fn new() -> Self { Self::with_map(HashMap::new()) }
-
-    /// Creates an empty linked hash map with the given initial capacity.
-    pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_map(HashMap::with_capacity(capacity))
-    }
-}
-
-impl<K, V, S> LinkedHashMap<K, V, S> {
-    fn clear_free_list(&mut self) {
-        unsafe {
-            let mut free = self.free;
-            while ! free.is_null() {
-                let next_free = (*free).next;
-                drop_empty_entry_box(free);
-                free = next_free;
-            }
-            self.free = ptr::null_mut();
-        }
-    }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
-    fn with_map(map: HashMap<KeyRef<K>, Box<LinkedHashMapEntry<K, V>>, S>) -> Self {
-        LinkedHashMap {
-            map: map,
-            head: ptr::null_mut(),
-            free: ptr::null_mut(),
-        }
-    }
-
-    /// Creates an empty linked hash map with the given initial hash state.
-    pub fn with_hash_state(hash_state: S) -> Self {
-        Self::with_map(HashMap::with_hasher(hash_state))
-    }
-
-    /// Creates an empty linked hash map with the given initial capacity and hash state.
-    pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S) -> Self {
-        Self::with_map(HashMap::with_capacity_and_hasher(capacity, hash_state))
-    }
-
-    /// Reserves capacity for at least `additional` more elements to be inserted into the map. The
-    /// map may reserve more space to avoid frequent allocations.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new allocation size overflows `usize.`
-    pub fn reserve(&mut self, additional: usize) { self.map.reserve(additional); }
-
-    /// Shrinks the capacity of the map as much as possible. It will drop down as much as possible
-    /// while maintaining the internal rules and possibly leaving some space in accordance with the
-    /// resize policy.
-    pub fn shrink_to_fit(&mut self) {
-        self.map.shrink_to_fit();
-        self.clear_free_list();
-    }
-
-    /// Inserts a key-value pair into the map. If the key already existed, the old value is
-    /// returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    ///
-    /// map.insert(1, "a");
-    /// map.insert(2, "b");
-    /// assert_eq!(map[&1], "a");
-    /// assert_eq!(map[&2], "b");
-    /// ```
-    pub fn insert(&mut self, k: K, v: V) -> Option<V> {
-        if self.head.is_null() {
-            // allocate the guard node if not present
-            unsafe {
-                self.head = Box::into_raw(Box::new(mem::uninitialized()));
-                (*self.head).next = self.head;
-                (*self.head).prev = self.head;
-            }
-        }
-        let (node_ptr, node_opt, old_val) = match self.map.get_mut(&KeyRef{k: &k}) {
-            Some(node) => {
-                let old_val = mem::replace(&mut node.value, v);
-                let node_ptr: *mut LinkedHashMapEntry<K, V> = &mut **node;
-                (node_ptr, None, Some(old_val))
-            }
-            None => {
-                let mut node = if self.free.is_null() {
-                    Box::new(LinkedHashMapEntry::new(k, v))
-                } else {
-                    // use a recycled box
-                    unsafe {
-                        let free = self.free;
-                        self.free = (*free).next;
-                        ptr::write(free, LinkedHashMapEntry::new(k, v));
-                        Box::from_raw(free)
-                    }
-                };
-                let node_ptr: *mut LinkedHashMapEntry<K, V> = &mut *node;
-                (node_ptr, Some(node), None)
-            }
-        };
-        match node_opt {
-            None => {
-                // Existing node, just update LRU position
-                self.detach(node_ptr);
-                self.attach(node_ptr);
-            }
-            Some(node) => {
-                let keyref = unsafe { &(*node_ptr).key };
-                self.map.insert(KeyRef{k: keyref}, node);
-                self.attach(node_ptr);
-            }
-        }
-        old_val
-    }
-
-    /// Checks if the map contains the given key.
-    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool where K: Borrow<Q>, Q: Eq + Hash {
-        self.map.contains_key(Qey::from_ref(k))
-    }
-
-    /// Returns the value corresponding to the key in the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    ///
-    /// map.insert(1, "a");
-    /// map.insert(2, "b");
-    /// map.insert(2, "c");
-    /// map.insert(3, "d");
-    ///
-    /// assert_eq!(map.get(&1), Some(&"a"));
-    /// assert_eq!(map.get(&2), Some(&"c"));
-    /// ```
-    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V> where K: Borrow<Q>, Q: Eq + Hash {
-        self.map.get(Qey::from_ref(k)).map(|e| &e.value)
-    }
-
-    /// Returns the mutable reference corresponding to the key in the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    ///
-    /// map.insert(1, "a");
-    /// map.insert(2, "b");
-    ///
-    /// *map.get_mut(&1).unwrap() = "c";
-    /// assert_eq!(map.get(&1), Some(&"c"));
-    /// ```
-    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Eq + Hash {
-        self.map.get_mut(Qey::from_ref(k)).map(|e| &mut e.value)
-    }
-
-    /// Returns the value corresponding to the key in the map.
-    ///
-    /// If value is found, it is moved to the end of the list.
-    /// This operation can be used in implemenation of LRU cache.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    ///
-    /// map.insert(1, "a");
-    /// map.insert(2, "b");
-    /// map.insert(3, "d");
-    ///
-    /// assert_eq!(map.get_refresh(&2), Some(&mut "b"));
-    ///
-    /// assert_eq!((&2, &"b"), map.iter().rev().next().unwrap());
-    /// ```
-    pub fn get_refresh<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V> where K: Borrow<Q>, Q: Eq + Hash {
-        let (value, node_ptr_opt) = match self.map.get_mut(Qey::from_ref(k)) {
-            None => (None, None),
-            Some(node) => {
-                let node_ptr: *mut LinkedHashMapEntry<K, V> = &mut **node;
-                (Some(unsafe { &mut(*node_ptr).value }), Some(node_ptr))
-            }
-        };
-        if let Some(node_ptr) = node_ptr_opt {
-            self.detach(node_ptr);
-            self.attach(node_ptr);
-        }
-        return value;
-    }
-
-    /// Removes and returns the value corresponding to the key from the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    ///
-    /// map.insert(2, "a");
-    ///
-    /// assert_eq!(map.remove(&1), None);
-    /// assert_eq!(map.remove(&2), Some("a"));
-    /// assert_eq!(map.remove(&2), None);
-    /// assert_eq!(map.len(), 0);
-    /// ```
-    pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V> where K: Borrow<Q>, Q: Eq + Hash {
-        let removed = self.map.remove(Qey::from_ref(k));
-        removed.map(|mut node| {
-            let node_ptr: *mut LinkedHashMapEntry<K,V> = &mut *node;
-            self.detach(node_ptr);
-            unsafe {
-                // add to free list
-                (*node_ptr).next = self.free;
-                self.free = node_ptr;
-                // forget the box but drop the key and return the value
-                mem::forget(node);
-                drop(ptr::read(&(*node_ptr).key));
-                ptr::read(&(*node_ptr).value)
-            }
-        })
-    }
-
-    /// Returns the maximum number of key-value pairs the map can hold without reallocating.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map: LinkedHashMap<i32, &str> = LinkedHashMap::new();
-    /// let capacity = map.capacity();
-    /// ```
-    pub fn capacity(&self) -> usize {
-        self.map.capacity()
-    }
-
-    /// Removes the first entry.
-    ///
-    /// Can be used in implementation of LRU cache.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert(1, 10);
-    /// map.insert(2, 20);
-    /// map.pop_front();
-    /// assert_eq!(map.get(&1), None);
-    /// assert_eq!(map.get(&2), Some(&20));
-    /// ```
-    #[inline]
-    pub fn pop_front(&mut self) -> Option<(K, V)> {
-        if self.len() > 0 {
-            let lru = unsafe { (*self.head).prev };
-            self.detach(lru);
-            return self.map
-                .remove(&KeyRef{k: unsafe { &(*lru).key }})
-                .map(|e| { let e = *e; (e.key, e.value) })
-        }
-        None
-    }
-
-    /// Gets the first entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert(1, 10);
-    /// map.insert(2, 20);
-    /// assert_eq!(map.front(), Some((&1, &10)));
-    /// ```
-    #[inline]
-    pub fn front(&self) -> Option<(&K, &V)> {
-        if self.len() > 0 {
-            let lru = unsafe { (*self.head).prev };
-            return self.map.get(&KeyRef{k: unsafe { &(*lru).key }})
-                .map(|e| (&e.key, &e.value))
-        }
-        None
-    }
-
-    /// Removes the last entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert(1, 10);
-    /// map.insert(2, 20);
-    /// map.pop_back();
-    /// assert_eq!(map.get(&1), Some(&10));
-    /// assert_eq!(map.get(&2), None);
-    /// ```
-    #[inline]
-    pub fn pop_back(&mut self) -> Option<(K, V)> {
-        if self.len() > 0 {
-            let mru = unsafe { (*self.head).next };
-            self.detach(mru);
-            return self.map
-                .remove(&KeyRef{k: unsafe { &(*mru).key }})
-                .map(|e| { let e = *e; (e.key, e.value) })
-        }
-        None
-    }
-
-    /// Gets the last entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert(1, 10);
-    /// map.insert(2, 20);
-    /// assert_eq!(map.back(), Some((&2, &20)));
-    /// ```
-    #[inline]
-    pub fn back(&mut self) -> Option<(&K, &V)> {
-        if self.len() > 0 {
-            let mru = unsafe { (*self.head).next };
-            return self.map.get(&KeyRef{k: unsafe { &(*mru).key }})
-                .map(|e| (&e.key, &e.value))
-        }
-        None
-    }
-
-    /// Returns the number of key-value pairs in the map.
-    pub fn len(&self) -> usize { self.map.len() }
-
-    /// Returns whether the map is currently empty.
-    pub fn is_empty(&self) -> bool { self.len() == 0 }
-
-    /// Clears the map of all key-value pairs.
-    pub fn clear(&mut self) {
-        self.map.clear();
-        // update the guard node if present
-        if ! self.head.is_null() {
-            unsafe {
-                (*self.head).prev = self.head;
-                (*self.head).next = self.head;
-            }
-        }
-    }
-
-    /// Returns a double-ended iterator visiting all key-value pairs in order of insertion.
-    /// Iterator element type is `(&'a K, &'a V)`
-    ///
-    /// # Examples
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    ///
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert("a", 10);
-    /// map.insert("c", 30);
-    /// map.insert("b", 20);
-    ///
-    /// let mut iter = map.iter();
-    /// assert_eq!((&"a", &10), iter.next().unwrap());
-    /// assert_eq!((&"c", &30), iter.next().unwrap());
-    /// assert_eq!((&"b", &20), iter.next().unwrap());
-    /// assert_eq!(None, iter.next());
-    /// ```
-    pub fn iter(&self) -> Iter<K, V> {
-        let head = if ! self.head.is_null() {
-            unsafe { (*self.head).prev }
-        } else {
-            ptr::null_mut()
-        };
-        Iter {
-            head: head,
-            tail: self.head,
-            remaining: self.len(),
-            marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns a double-ended iterator visiting all key-value pairs in order of insertion.
-    /// Iterator element type is `(&'a K, &'a mut V)`
-    /// # Examples
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    ///
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert("a", 10);
-    /// map.insert("c", 30);
-    /// map.insert("b", 20);
-    ///
-    /// {
-    ///     let mut iter = map.iter_mut();
-    ///     let mut entry = iter.next().unwrap();
-    ///     assert_eq!(&"a", entry.0);
-    ///     *entry.1 = 17;
-    /// }
-    ///
-    /// assert_eq!(&17, map.get(&"a").unwrap());
-    /// ```
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
-        let head = if ! self.head.is_null() {
-            unsafe { (*self.head).prev }
-        } else {
-            ptr::null_mut()
-        };
-        IterMut {
-            head: head,
-            tail: self.head,
-            remaining: self.len(),
-            marker: marker::PhantomData,
-        }
-    }
-
-    /// Returns a double-ended iterator visiting all key in order of insertion.
-    ///
-    /// # Examples
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    ///
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert('a', 10);
-    /// map.insert('c', 30);
-    /// map.insert('b', 20);
-    ///
-    /// let mut keys = map.keys();
-    /// assert_eq!(&'a', keys.next().unwrap());
-    /// assert_eq!(&'c', keys.next().unwrap());
-    /// assert_eq!(&'b', keys.next().unwrap());
-    /// assert_eq!(None, keys.next());
-    /// ```
-    pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
-        fn first<A, B>((a, _): (A, B)) -> A { a }
-        let first: fn((&'a K, &'a V)) -> &'a K = first; // coerce to fn ptr
-
-        Keys { inner: self.iter().map(first) }
-    }
-
-    /// Returns a double-ended iterator visiting all values in order of insertion.
-    ///
-    /// # Examples
-    /// ```
-    /// use linked_hash_map::LinkedHashMap;
-    ///
-    /// let mut map = LinkedHashMap::new();
-    /// map.insert('a', 10);
-    /// map.insert('c', 30);
-    /// map.insert('b', 20);
-    ///
-    /// let mut values = map.values();
-    /// assert_eq!(&10, values.next().unwrap());
-    /// assert_eq!(&30, values.next().unwrap());
-    /// assert_eq!(&20, values.next().unwrap());
-    /// assert_eq!(None, values.next());
-    /// ```
-    pub fn values<'a>(&'a self) -> Values<'a, K, V> {
-        fn second<A, B>((_, b): (A, B)) -> B { b }
-        let second: fn((&'a K, &'a V)) -> &'a V = second; // coerce to fn ptr
-
-        Values { inner: self.iter().map(second) }
-    }
-}
-
-impl<'a, K, V, S, Q: ?Sized> Index<&'a Q> for LinkedHashMap<K, V, S>
-    where K: Hash + Eq + Borrow<Q>, S: BuildHasher, Q: Eq + Hash
-{
-    type Output = V;
-
-    fn index(&self, index: &'a Q) -> &V {
-        self.get(index).expect("no entry found for key")
-    }
-}
-
-impl<'a, K, V, S, Q: ?Sized> IndexMut<&'a Q> for LinkedHashMap<K, V, S>
-    where K: Hash + Eq + Borrow<Q>, S: BuildHasher, Q: Eq + Hash
-{
-    fn index_mut(&mut self, index: &'a Q) -> &mut V {
-        self.get_mut(index).expect("no entry found for key")
-    }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher> LinkedHashMap<K, V, S> {
-    #[inline]
-    fn detach(&mut self, node: *mut LinkedHashMapEntry<K, V>) {
-        unsafe {
-            (*(*node).prev).next = (*node).next;
-            (*(*node).next).prev = (*node).prev;
-        }
-    }
-
-    #[inline]
-    fn attach(&mut self, node: *mut LinkedHashMapEntry<K, V>) {
-        unsafe {
-            (*node).next = (*self.head).next;
-            (*node).prev = self.head;
-            (*self.head).next = node;
-            (*(*node).next).prev = node;
-        }
-    }
-}
-
-#[cfg(not(feature = "nightly"))]
-impl<K: Hash + Eq + Clone, V: Clone> Clone for LinkedHashMap<K, V> {
-    fn clone(&self) -> Self {
-        self.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
-    }
-}
-
-#[cfg(feature = "nightly")]
-impl<K: Hash + Eq + Clone, V: Clone, S: BuildHasher + Clone> Clone for LinkedHashMap<K, V, S> {
-    fn clone(&self) -> Self {
-        let mut map = Self::with_hash_state(self.map.hasher().clone());
-        map.extend(self.iter().map(|(k, v)| (k.clone(), v.clone())));
-        map
-    }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher + Default> Default for LinkedHashMap<K, V, S> {
-    fn default() -> Self { LinkedHashMap::with_hash_state(Default::default()) }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher> Extend<(K, V)> for LinkedHashMap<K, V, S> {
-    fn extend<T: IntoIterator<Item=(K, V)>>(&mut self, iter: T) {
-        for (k, v) in iter {
-            self.insert(k, v);
-        }
-    }
-}
-
-impl<'a, K, V, S> Extend<(&'a K, &'a V)> for LinkedHashMap<K, V, S>
-    where K: 'a + Hash + Eq + Copy, V: 'a + Copy, S: BuildHasher,
-{
-    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {
-        for (&k, &v) in iter {
-            self.insert(k, v);
-        }
-    }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher + Default> iter::FromIterator<(K, V)> for LinkedHashMap<K, V, S> {
-    fn from_iter<I: IntoIterator<Item=(K, V)>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let mut map = Self::with_capacity_and_hash_state(iter.size_hint().0, Default::default());
-        map.extend(iter);
-        map
-    }
-}
-
-impl<A: fmt::Debug + Hash + Eq, B: fmt::Debug, S: BuildHasher> fmt::Debug for LinkedHashMap<A, B, S> {
-    /// Returns a string that lists the key-value pairs in insertion order.
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_map().entries(self).finish()
-    }
-}
-
-impl<K: Hash + Eq, V: PartialEq, S: BuildHasher> PartialEq for LinkedHashMap<K, V, S> {
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self.iter().eq(other)
-    }
-
-    fn ne(&self, other: &Self) -> bool {
-        self.len() != other.len() || self.iter().ne(other)
-    }
-}
-
-impl<K: Hash + Eq, V: Eq, S: BuildHasher> Eq for LinkedHashMap<K, V, S> {}
-
-impl<K: Hash + Eq + PartialOrd, V: PartialOrd, S: BuildHasher> PartialOrd for LinkedHashMap<K, V, S> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.iter().partial_cmp(other)
-    }
-
-    fn lt(&self, other: &Self) -> bool {
-        self.iter().lt(other)
-    }
-
-    fn le(&self, other: &Self) -> bool {
-        self.iter().le(other)
-    }
-
-    fn ge(&self, other: &Self) -> bool {
-        self.iter().ge(other)
-    }
-
-    fn gt(&self, other: &Self) -> bool {
-        self.iter().gt(other)
-    }
-}
-
-impl<K: Hash + Eq + Ord, V: Ord, S: BuildHasher> Ord for LinkedHashMap<K, V, S> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.iter().cmp(other)
-    }
-}
-
-impl<K: Hash + Eq, V: Hash, S: BuildHasher> Hash for LinkedHashMap<K, V, S> {
-    fn hash<H: Hasher>(&self, h: &mut H) { for e in self.iter() { e.hash(h); } }
-}
-
-unsafe impl<K: Send, V: Send, S: Send> Send for LinkedHashMap<K, V, S> {}
-
-unsafe impl<K: Sync, V: Sync, S: Sync> Sync for LinkedHashMap<K, V, S> {}
-
-impl<K, V, S> Drop for LinkedHashMap<K, V, S> {
-    fn drop(&mut self) {
-        unsafe {
-            if ! self.head.is_null() {
-                drop_empty_entry_box(self.head);
-            }
-            self.clear_free_list();
-        }
-    }
-}
-
-/// An insertion-order iterator over a `LinkedHashMap`'s entries, with immutable references to the
-/// values.
-pub struct Iter<'a, K: 'a, V: 'a> {
-    head: *const LinkedHashMapEntry<K, V>,
-    tail: *const LinkedHashMapEntry<K, V>,
-    remaining: usize,
-    marker: marker::PhantomData<(&'a K, &'a V)>,
-}
-
-/// An insertion-order iterator over a `LinkedHashMap`'s entries, with mutable references to the
-/// values.
-pub struct IterMut<'a, K: 'a, V: 'a> {
-    head: *mut LinkedHashMapEntry<K, V>,
-    tail: *mut LinkedHashMapEntry<K, V>,
-    remaining: usize,
-    marker: marker::PhantomData<(&'a K, &'a mut V)>,
-}
-
-unsafe impl<'a, K, V> Send for Iter<'a, K, V> where K: Send, V: Send {}
-
-unsafe impl<'a, K, V> Send for IterMut<'a, K, V> where K: Send, V: Send {}
-
-unsafe impl<'a, K, V> Sync for Iter<'a, K, V> where K: Sync, V: Sync {}
-
-unsafe impl<'a, K, V> Sync for IterMut<'a, K, V> where K: Sync, V: Sync {}
-
-impl<'a, K, V> Clone for Iter<'a, K, V> {
-    fn clone(&self) -> Self { Iter { ..*self } }
-}
-
-impl<'a, K, V> Iterator for Iter<'a, K, V> {
-    type Item = (&'a K, &'a V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.head == self.tail {
-            None
-        } else {
-            self.remaining -= 1;
-            unsafe {
-                let r = Some((&(*self.head).key, &(*self.head).value));
-                self.head = (*self.head).prev;
-                r
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.remaining, Some(self.remaining))
-    }
-}
-
-impl<'a, K, V> Iterator for IterMut<'a, K, V> {
-    type Item = (&'a K, &'a mut V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.head == self.tail {
-            None
-        } else {
-            self.remaining -= 1;
-            unsafe {
-                let r = Some((&(*self.head).key, &mut (*self.head).value));
-                self.head = (*self.head).prev;
-                r
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.remaining, Some(self.remaining))
-    }
-}
-
-impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.head == self.tail {
-            None
-        } else {
-            self.remaining -= 1;
-            unsafe {
-                self.tail = (*self.tail).next;
-                let r = Some((&(*self.tail).key, &(*self.tail).value));
-                r
-            }
-        }
-    }
-}
-
-impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.head == self.tail {
-            None
-        } else {
-            self.remaining -= 1;
-            unsafe {
-                self.tail = (*self.tail).next;
-                let r = Some((&(*self.tail).key, &mut (*self.tail).value));
-                r
-            }
-        }
-    }
-}
-
-impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
-    fn len(&self) -> usize { self.remaining }
-}
-
-impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
-    fn len(&self) -> usize { self.remaining }
-}
-
-/// An insertion-order iterator over a `LinkedHashMap`'s keys.
-pub struct Keys<'a, K: 'a, V: 'a> {
-    inner: iter::Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K>
-}
-
-impl<'a, K, V> Clone for Keys<'a, K, V> {
-    fn clone(&self) -> Self { Keys { inner: self.inner.clone() } }
-}
-
-impl<'a, K, V> Iterator for Keys<'a, K, V> {
-    type Item = &'a K;
-
-    #[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
-    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
-}
-
-impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
-    #[inline] fn next_back(&mut self) -> Option<(&'a K)> { self.inner.next_back() }
-}
-
-impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
-    fn len(&self) -> usize { self.inner.len() }
-}
-
-/// An insertion-order iterator over a `LinkedHashMap`'s values.
-pub struct Values<'a, K: 'a, V: 'a> {
-    inner: iter::Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
-}
-
-impl<'a, K, V> Clone for Values<'a, K, V> {
-    fn clone(&self) -> Self { Values { inner: self.inner.clone() } }
-}
-
-impl<'a, K, V> Iterator for Values<'a, K, V> {
-    type Item = &'a V;
-
-    #[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
-    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
-}
-
-impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
-    #[inline] fn next_back(&mut self) -> Option<(&'a V)> { self.inner.next_back() }
-}
-
-impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
-    fn len(&self) -> usize { self.inner.len() }
-}
-
-impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a LinkedHashMap<K, V, S> {
-    type Item = (&'a K, &'a V);
-    type IntoIter = Iter<'a, K, V>;
-    fn into_iter(self) -> Iter<'a, K, V> { self.iter() }
-}
-
-impl<'a, K: Hash + Eq, V, S: BuildHasher> IntoIterator for &'a mut LinkedHashMap<K, V, S> {
-    type Item = (&'a K, &'a mut V);
-    type IntoIter = IterMut<'a, K, V>;
-    fn into_iter(self) -> IterMut<'a, K, V> { self.iter_mut() }
-}
-
-#[cfg(all(feature = "nightly", test))]
-mod bench {
-    extern crate test;
-
-    use super::LinkedHashMap;
-
-    #[bench]
-    fn not_recycled_cycling(b: &mut test::Bencher) {
-        let mut hash_map = LinkedHashMap::with_capacity(1000);
-        for i in 0usize..1000 {
-            hash_map.insert(i, i);
-        }
-        b.iter(|| {
-            for i in 0usize..1000 {
-                hash_map.remove(&i);
-            }
-            hash_map.clear_free_list();
-            for i in 0usize..1000 {
-                hash_map.insert(i, i);
-            }
-        })
-    }
-
-    #[bench]
-    fn recycled_cycling(b: &mut test::Bencher) {
-        let mut hash_map = LinkedHashMap::with_capacity(1000);
-        for i in 0usize..1000 {
-            hash_map.insert(i, i);
-        }
-        b.iter(|| {
-            for i in 0usize..1000 {
-                hash_map.remove(&i);
-            }
-            for i in 0usize..1000 {
-                hash_map.insert(i, i);
-            }
-        })
-    }
-}

mount/cache/lru_cache.rs

-// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A cache that holds a limited number of key-value pairs. When the
-//! capacity of the cache is exceeded, the least-recently-used
-//! (where "used" means a look-up or putting the pair into the cache)
-//! pair is automatically removed.
-//!
-//! # Examples
-//!
-//! ```
-//! use lru_cache::LruCache;
-//!
-//! let mut cache = LruCache::new(2);
-//!
-//! cache.insert(1, 10);
-//! cache.insert(2, 20);
-//! cache.insert(3, 30);
-//! assert!(cache.get_mut(&1).is_none());
-//! assert_eq!(*cache.get_mut(&2).unwrap(), 20);
-//! assert_eq!(*cache.get_mut(&3).unwrap(), 30);
-//!
-//! cache.insert(2, 22);
-//! assert_eq!(*cache.get_mut(&2).unwrap(), 22);
-//!
-//! cache.insert(6, 60);
-//! assert!(cache.get_mut(&3).is_none());
-//!
-//! cache.set_capacity(1);
-//! assert!(cache.get_mut(&2).is_none());
-//! ```
-
-use std::collections::hash_map::RandomState;
-use std::fmt;
-use std::hash::{Hash, BuildHasher};
-use std::borrow::Borrow;
-
-use super::linked_hash_map::{self, LinkedHashMap};
-
-// FIXME(conventions): implement indexing?
-
-/// An LRU cache.
-pub struct LruCache<K, V, S = RandomState> where K: Eq + Hash, S: BuildHasher {
-    map: LinkedHashMap<K, V, S>,
-    max_size: usize,
-}
-
-impl<K: Hash + Eq, V> LruCache<K, V> {
-    /// Creates an empty cache that can hold at most `capacity` items.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    /// let mut cache: LruCache<i32, &str> = LruCache::new(10);
-    /// ```
-    pub fn new(capacity: usize) -> LruCache<K, V> {
-        LruCache {
-            map: LinkedHashMap::new(),
-            max_size: capacity,
-        }
-    }
-}
-
-impl<K, V, S> LruCache<K, V, S> where K: Eq + Hash, S: BuildHasher {
-    /// Creates an empty cache that can hold at most `capacity` items with the given hash state.
-    pub fn with_hash_state(capacity: usize, hash_state: S) -> LruCache<K, V, S> {
-        LruCache { map: LinkedHashMap::with_hash_state(hash_state), max_size: capacity }
-    }
-
-    /// Checks if the map contains the given key.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(1);
-    ///
-    /// cache.insert(1, "a");
-    /// assert_eq!(cache.contains_key(&1), true);
-    /// ```
-    pub fn contains_key<Q: ?Sized>(&mut self, key: &Q) -> bool
-        where K: Borrow<Q>,
-              Q: Hash + Eq
-    {
-        self.get_mut(key).is_some()
-    }
-
-    /// Inserts a key-value pair into the cache. If the key already existed, the old value is
-    /// returned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(1, "a");
-    /// cache.insert(2, "b");
-    /// assert_eq!(cache.get_mut(&1), Some(&mut "a"));
-    /// assert_eq!(cache.get_mut(&2), Some(&mut "b"));
-    /// ```
-    pub fn insert(&mut self, k: K, v: V) -> Option<V> {
-        let old_val = self.map.insert(k, v);
-        if self.len() > self.capacity() {
-            self.remove_lru();
-        }
-        old_val
-    }
-
-    /// Returns a mutable reference to the value corresponding to the given key in the cache, if
-    /// any.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(1, "a");
-    /// cache.insert(2, "b");
-    /// cache.insert(2, "c");
-    /// cache.insert(3, "d");
-    ///
-    /// assert_eq!(cache.get_mut(&1), None);
-    /// assert_eq!(cache.get_mut(&2), Some(&mut "c"));
-    /// ```
-    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
-        where K: Borrow<Q>,
-              Q: Hash + Eq
-    {
-        self.map.get_refresh(k)
-    }
-
-    /// Removes the given key from the cache and returns its corresponding value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(2, "a");
-    ///
-    /// assert_eq!(cache.remove(&1), None);
-    /// assert_eq!(cache.remove(&2), Some("a"));
-    /// assert_eq!(cache.remove(&2), None);
-    /// assert_eq!(cache.len(), 0);
-    /// ```
-    pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
-        where K: Borrow<Q>,
-              Q: Hash + Eq
-    {
-        self.map.remove(k)
-    }
-
-    /// Returns the maximum number of key-value pairs the cache can hold.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    /// let mut cache: LruCache<i32, &str> = LruCache::new(2);
-    /// assert_eq!(cache.capacity(), 2);
-    /// ```
-    pub fn capacity(&self) -> usize {
-        self.max_size
-    }
-
-    /// Sets the number of key-value pairs the cache can hold. Removes
-    /// least-recently-used key-value pairs if necessary.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(1, "a");
-    /// cache.insert(2, "b");
-    /// cache.insert(3, "c");
-    ///
-    /// assert_eq!(cache.get_mut(&1), None);
-    /// assert_eq!(cache.get_mut(&2), Some(&mut "b"));
-    /// assert_eq!(cache.get_mut(&3), Some(&mut "c"));
-    ///
-    /// cache.set_capacity(3);
-    /// cache.insert(1, "a");
-    /// cache.insert(2, "b");
-    ///
-    /// assert_eq!(cache.get_mut(&1), Some(&mut "a"));
-    /// assert_eq!(cache.get_mut(&2), Some(&mut "b"));
-    /// assert_eq!(cache.get_mut(&3), Some(&mut "c"));
-    ///
-    /// cache.set_capacity(1);
-    ///
-    /// assert_eq!(cache.get_mut(&1), None);
-    /// assert_eq!(cache.get_mut(&2), None);
-    /// assert_eq!(cache.get_mut(&3), Some(&mut "c"));
-    /// ```
-    pub fn set_capacity(&mut self, capacity: usize) {
-        for _ in capacity..self.len() {
-            self.remove_lru();
-        }
-        self.max_size = capacity;
-    }
-
-    #[inline]
-    fn remove_lru(&mut self) -> Option<(K, V)> {
-        self.map.pop_front()
-    }
-
-    /// Returns the number of key-value pairs in the cache.
-    pub fn len(&self) -> usize { self.map.len() }
-
-    /// Returns `true` if the cache contains no key-value pairs.
-    pub fn is_empty(&self) -> bool { self.map.is_empty() }
-
-    /// Removes all key-value pairs from the cache.
-    pub fn clear(&mut self) { self.map.clear(); }
-
-    /// Returns an iterator over the cache's key-value pairs in least- to most-recently-used order.
-    ///
-    /// Accessing the cache through the iterator does _not_ affect the cache's LRU state.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(1, 10);
-    /// cache.insert(2, 20);
-    /// cache.insert(3, 30);
-    ///
-    /// let kvs: Vec<_> = cache.iter().collect();
-    /// assert_eq!(kvs, [(&2, &20), (&3, &30)]);
-    /// ```
-    pub fn iter(&self) -> Iter<K, V> { Iter(self.map.iter()) }
-
-    /// Returns an iterator over the cache's key-value pairs in least- to most-recently-used order,
-    /// with mutable references to the values.
-    ///
-    /// Accessing the cache through the iterator does _not_ affect the cache's LRU state.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use lru_cache::LruCache;
-    ///
-    /// let mut cache = LruCache::new(2);
-    ///
-    /// cache.insert(1, 10);
-    /// cache.insert(2, 20);
-    /// cache.insert(3, 30);
-    ///
-    /// let mut n = 2;
-    ///
-    /// for (k, v) in cache.iter_mut() {
-    ///     assert_eq!(*k, n);
-    ///     assert_eq!(*v, n * 10);
-    ///     *v *= 10;
-    ///     n += 1;
-    /// }
-    ///
-    /// assert_eq!(n, 4);
-    /// assert_eq!(cache.get_mut(&2), Some(&mut 200));
-    /// assert_eq!(cache.get_mut(&3), Some(&mut 300));
-    /// ```
-    pub fn iter_mut(&mut self) -> IterMut<K, V> { IterMut(self.map.iter_mut()) }
-}
-
-impl<K: Hash + Eq, V, S: BuildHasher> Extend<(K, V)> for LruCache<K, V, S> {
-    fn extend<T: IntoIterator<Item=(K, V)>>(&mut self, iter: T) {
-        for (k, v) in iter {
-            self.insert(k, v);
-        }
-    }
-}
-
-impl<A: fmt::Debug + Hash + Eq, B: fmt::Debug, S: BuildHasher> fmt::Debug for LruCache<A, B, S> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_map().entries(self.iter().rev()).finish()
-    }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a LruCache<K, V, S> where K: Eq + Hash, S: BuildHasher {
-    type Item = (&'a K, &'a V);
-    type IntoIter = Iter<'a, K, V>;
-    fn into_iter(self) -> Iter<'a, K, V> { self.iter() }
-}
-
-impl<'a, K, V, S> IntoIterator for &'a mut LruCache<K, V, S> where K: Eq + Hash, S: BuildHasher {
-    type Item = (&'a K, &'a mut V);
-    type IntoIter = IterMut<'a, K, V>;
-    fn into_iter(self) -> IterMut<'a, K, V> { self.iter_mut() }
-}
-
-impl<K, V> Clone for LruCache<K, V> where K: Clone + Eq + Hash, V: Clone {
-    fn clone(&self) -> LruCache<K, V> { LruCache { map: self.map.clone(), ..*self } }
-}
-
-/// An iterator over a cache's key-value pairs in least- to most-recently-used order.
-///
-/// Accessing a cache through the iterator does _not_ affect the cache's LRU state.
-pub struct Iter<'a, K: 'a, V: 'a>(linked_hash_map::Iter<'a, K, V>);
-
-impl<'a, K, V> Clone for Iter<'a, K, V> {
-    fn clone(&self) -> Iter<'a, K, V> { Iter(self.0.clone()) }
-}
-
-impl<'a, K, V> Iterator for Iter<'a, K, V> {
-    type Item = (&'a K, &'a V);
-    fn next(&mut self) -> Option<(&'a K, &'a V)> { self.0.next() }
-    fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
-}
-
-impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a V)> { self.0.next_back() }
-}
-
-impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {
-    fn len(&self) -> usize { self.0.len() }
-}
-
-/// An iterator over a cache's key-value pairs in least- to most-recently-used order with mutable
-/// references to the values.
-///
-/// Accessing a cache through the iterator does _not_ affect the cache's LRU state.
-pub struct IterMut<'a, K: 'a, V: 'a>(linked_hash_map::IterMut<'a, K, V>);
-
-impl<'a, K, V> Iterator for IterMut<'a, K, V> {
-    type Item = (&'a K, &'a mut V);
-    fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.0.next() }
-    fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
-}
-
-impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> { self.0.next_back() }
-}
-
-impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {
-    fn len(&self) -> usize { self.0.len() }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::LruCache;
-
-    #[test]
-    fn test_put_and_get() {
-        let mut cache = LruCache::new(2);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        assert_eq!(cache.get_mut(&1), Some(&mut 10));
-        assert_eq!(cache.get_mut(&2), Some(&mut 20));
-        assert_eq!(cache.len(), 2);
-    }
-
-    #[test]
-    fn test_put_update() {
-        let mut cache = LruCache::new(1);
-        cache.insert("1", 10);
-        cache.insert("1", 19);
-        assert_eq!(cache.get_mut("1"), Some(&mut 19));
-        assert_eq!(cache.len(), 1);
-    }
-
-    #[test]
-    fn test_contains_key() {
-        let mut cache = LruCache::new(1);
-        cache.insert("1", 10);
-        assert_eq!(cache.contains_key("1"), true);
-    }
-
-    #[test]
-    fn test_expire_lru() {
-        let mut cache = LruCache::new(2);
-        cache.insert("foo1", "bar1");
-        cache.insert("foo2", "bar2");
-        cache.insert("foo3", "bar3");
-        assert!(cache.get_mut("foo1").is_none());
-        cache.insert("foo2", "bar2update");
-        cache.insert("foo4", "bar4");
-        assert!(cache.get_mut("foo3").is_none());
-    }
-
-    #[test]
-    fn test_pop() {
-        let mut cache = LruCache::new(2);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        assert_eq!(cache.len(), 2);
-        let opt1 = cache.remove(&1);
-        assert!(opt1.is_some());
-        assert_eq!(opt1.unwrap(), 10);
-        assert!(cache.get_mut(&1).is_none());
-        assert_eq!(cache.len(), 1);
-    }
-
-    #[test]
-    fn test_change_capacity() {
-        let mut cache = LruCache::new(2);
-        assert_eq!(cache.capacity(), 2);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        cache.set_capacity(1);
-        assert!(cache.get_mut(&1).is_none());
-        assert_eq!(cache.capacity(), 1);
-    }
-
-    #[test]
-    fn test_debug() {
-        let mut cache = LruCache::new(3);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        cache.insert(3, 30);
-        assert_eq!(format!("{:?}", cache), "{3: 30, 2: 20, 1: 10}");
-        cache.insert(2, 22);
-        assert_eq!(format!("{:?}", cache), "{2: 22, 3: 30, 1: 10}");
-        cache.insert(6, 60);
-        assert_eq!(format!("{:?}", cache), "{6: 60, 2: 22, 3: 30}");
-        cache.get_mut(&3);
-        assert_eq!(format!("{:?}", cache), "{3: 30, 6: 60, 2: 22}");
-        cache.set_capacity(2);
-        assert_eq!(format!("{:?}", cache), "{3: 30, 6: 60}");
-    }
-
-    #[test]
-    fn test_remove() {
-        let mut cache = LruCache::new(3);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        cache.insert(3, 30);
-        cache.insert(4, 40);
-        cache.insert(5, 50);
-        cache.remove(&3);
-        cache.remove(&4);
-        assert!(cache.get_mut(&3).is_none());
-        assert!(cache.get_mut(&4).is_none());
-        cache.insert(6, 60);
-        cache.insert(7, 70);
-        cache.insert(8, 80);
-        assert!(cache.get_mut(&5).is_none());
-        assert_eq!(cache.get_mut(&6), Some(&mut 60));
-        assert_eq!(cache.get_mut(&7), Some(&mut 70));
-        assert_eq!(cache.get_mut(&8), Some(&mut 80));
-    }
-
-    #[test]
-    fn test_clear() {
-        let mut cache = LruCache::new(2);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        cache.clear();
-        assert!(cache.get_mut(&1).is_none());
-        assert!(cache.get_mut(&2).is_none());
-        assert_eq!(format!("{:?}", cache), "{}");
-    }
-
-    #[test]
-    fn test_iter() {
-        let mut cache = LruCache::new(3);
-        cache.insert(1, 10);
-        cache.insert(2, 20);
-        cache.insert(3, 30);
-        cache.insert(4, 40);
-        cache.insert(5, 50);
-        assert_eq!(cache.iter().collect::<Vec<_>>(),
-                   [(&3, &30), (&4, &40), (&5, &50)]);
-        assert_eq!(cache.iter_mut().collect::<Vec<_>>(),
-                   [(&3, &mut 30), (&4, &mut 40), (&5, &mut 50)]);
-        assert_eq!(cache.iter().rev().collect::<Vec<_>>(),
-                   [(&5, &50), (&4, &40), (&3, &30)]);
-        assert_eq!(cache.iter_mut().rev().collect::<Vec<_>>(),
-                   [(&5, &mut 50), (&4, &mut 40), (&3, &mut 30)]);
-    }
-}

mount/fuse.rs

-extern crate fuse;
-extern crate time;
-
-use redoxfs;
-use std::path::Path;
-use std::os::unix::ffi::OsStrExt;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use self::fuse::{FileType, FileAttr, Filesystem, Request, ReplyData, ReplyEntry, ReplyAttr, ReplyCreate, ReplyDirectory, ReplyEmpty, ReplyStatfs, ReplyWrite};
-use self::time::Timespec;
-
-pub use self::fuse::mount;
-
-const TTL: Timespec = Timespec { sec: 1, nsec: 0 };                 // 1 second
-
-const NULL_TIME: Timespec = Timespec { sec: 0, nsec: 0 };
-
-pub struct Fuse {
-    pub fs: redoxfs::FileSystem,
-}
-
-fn node_attr(node: &(u64, redoxfs::Node)) -> FileAttr {
-    FileAttr {
-        ino: node.0,
-        size: node.1.extents[0].length,
-        blocks: (node.1.extents[0].length + 511)/512,
-        atime: NULL_TIME,
-        mtime: Timespec {
-            sec: node.1.mtime as i64,
-            nsec: node.1.mtime_nsec as i32,
-        },
-        ctime: Timespec {
-            sec: node.1.ctime as i64,
-            nsec: node.1.ctime_nsec as i32,
-        },
-        crtime: NULL_TIME,
-        kind: if node.1.is_dir() {
-            FileType::Directory
-        } else if node.1.is_symlink() {
-            FileType::Symlink
-        } else {
-            FileType::RegularFile
-        },
-        perm: node.1.mode & redoxfs::Node::MODE_PERM,
-        nlink: 1,
-        uid: node.1.uid,
-        gid: node.1.gid,
-        rdev: 0,
-        flags: 0,
-    }
-}
-
-impl Filesystem for Fuse {
-    fn lookup(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEntry) {
-        match self.fs.find_node(name.to_str().unwrap(), parent_block) {
-            Ok(node) => {
-                reply.entry(&TTL, &node_attr(&node), 0);
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn getattr(&mut self, _req: &Request, block: u64, reply: ReplyAttr) {
-        match self.fs.node(block) {
-            Ok(node) => {
-                reply.attr(&TTL, &node_attr(&node));
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn setattr(&mut self, _req: &Request, block: u64, mode: Option<u32>,
-                uid: Option<u32>, gid: Option<u32>, size: Option<u64>,
-                _atime: Option<Timespec>, mtime: Option<Timespec>, _fh: Option<u64>,
-                _crtime: Option<Timespec>, _chgtime: Option<Timespec>, _bkuptime: Option<Timespec>,
-                _flags: Option<u32>, reply: ReplyAttr) {
-        if let Some(mode) = mode {
-            match self.fs.node(block) {
-                Ok(mut node) => if node.1.mode & redoxfs::Node::MODE_PERM != mode as u16 & redoxfs::Node::MODE_PERM {
-                    // println!("Chmod {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode);
-                    node.1.mode = (node.1.mode & redoxfs::Node::MODE_TYPE) | (mode as u16 & redoxfs::Node::MODE_PERM);
-                    if let Err(err) = self.fs.write_at(node.0, &node.1) {
-                        reply.error(err.errno as i32);
-                        return;
-                    }
-                },
-                Err(err) => {
-                    reply.error(err.errno as i32);
-                    return;
-                }
-            }
-        }
-
-        if let Some(uid) = uid {
-            match self.fs.node(block) {
-                Ok(mut node) => if node.1.uid != uid {
-                    node.1.uid = uid;
-                    if let Err(err) = self.fs.write_at(node.0, &node.1) {
-                        reply.error(err.errno as i32);
-                        return;
-                    }
-                },
-                Err(err) => {
-                    reply.error(err.errno as i32);
-                    return;
-                }
-            }
-        }
-
-        if let Some(gid) = gid {
-            match self.fs.node(block) {
-                Ok(mut node) => if node.1.gid != gid {
-                    node.1.gid = gid;
-                    if let Err(err) = self.fs.write_at(node.0, &node.1) {
-                        reply.error(err.errno as i32);
-                        return;
-                    }
-                },
-                Err(err) => {
-                    reply.error(err.errno as i32);
-                    return;
-                }
-            }
-        }
-
-        if let Some(size) = size {
-            if let Err(err) = self.fs.node_set_len(block, size) {
-                reply.error(err.errno as i32);
-                return;
-            }
-        }
-
-        if let Some(mtime) = mtime {
-            match self.fs.node(block) {
-                Ok(mut node) => {
-                    node.1.mtime = mtime.sec as u64;
-                    node.1.mtime_nsec = mtime.nsec as u32;
-                    if let Err(err) = self.fs.write_at(node.0, &node.1) {
-                        reply.error(err.errno as i32);
-                        return;
-                    }
-                },
-                Err(err) => {
-                    reply.error(err.errno as i32);
-                    return;
-                }
-            }
-        }
-
-        match self.fs.node(block) {
-            Ok(node) => {
-                reply.attr(&TTL, &node_attr(&node));
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn read(&mut self, _req: &Request, block: u64, _fh: u64, offset: u64, size: u32, reply: ReplyData) {
-        let mut data = vec![0; size as usize];
-        match self.fs.read_node(block, offset, &mut data) {
-            Ok(count) => {
-                reply.data(&data[..count]);
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn write(&mut self, _req: &Request, block: u64, _fh: u64, offset: u64, data: &[u8], _flags: u32, reply: ReplyWrite) {
-        let mtime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        match self.fs.write_node(block, offset, &data, mtime.as_secs(), mtime.subsec_nanos()) {
-            Ok(count) => {
-                reply.written(count as u32);
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn flush(&mut self, _req: &Request, _ino: u64, _fh: u64, _lock_owner: u64, reply: ReplyEmpty) {
-        reply.ok();
-    }
-
-    fn fsync(&mut self, _req: &Request, _ino: u64, _fh: u64, _datasync: bool, reply: ReplyEmpty) {
-        reply.ok();
-    }
-
-    fn readdir(&mut self, _req: &Request, parent_block: u64, _fh: u64, offset: u64, mut reply: ReplyDirectory) {
-        let mut children = Vec::new();
-        match self.fs.child_nodes(&mut children, parent_block) {
-            Ok(()) => {
-                let mut i;
-                let skip;
-                if offset == 0 {
-                    skip = 0;
-                    i = 0;
-                    reply.add(parent_block - self.fs.header.0, i, FileType::Directory, ".");
-                    i += 1;
-                    reply.add(parent_block - self.fs.header.0, i, FileType::Directory, "..");
-                    i += 1;
-                } else {
-                    i = offset + 1;
-                    skip = offset as usize - 1;
-                }
-
-                for child in children.iter().skip(skip) {
-                    let full = reply.add(child.0 - self.fs.header.0, i, if child.1.is_dir() {
-                        FileType::Directory
-                    } else {
-                        FileType::RegularFile
-                    }, child.1.name().unwrap());
-
-                    if full {
-                        break;
-                    }
-
-                    i += 1;
-                }
-                reply.ok();
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn create(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, flags: u32, reply: ReplyCreate) {
-        let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        match self.fs.create_node(redoxfs::Node::MODE_FILE | (mode as u16 & redoxfs::Node::MODE_PERM), name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
-            Ok(node) => {
-                // println!("Create {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode);
-                reply.created(&TTL, &node_attr(&node), 0, 0, flags);
-            },
-            Err(error) => {
-                reply.error(error.errno as i32);
-            }
-        }
-    }
-
-    fn mkdir(&mut self, _req: &Request, parent_block: u64, name: &Path, mode: u32, reply: ReplyEntry) {
-        let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        match self.fs.create_node(redoxfs::Node::MODE_DIR | (mode as u16 & redoxfs::Node::MODE_PERM), name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
-            Ok(node) => {
-                // println!("Mkdir {:?}:{:o}:{:o}", node.1.name(), node.1.mode, mode);
-                reply.entry(&TTL, &node_attr(&node), 0);
-            },
-            Err(error) => {
-                reply.error(error.errno as i32);
-            }
-        }
-    }
-
-    fn rmdir(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEmpty) {
-        match self.fs.remove_node(redoxfs::Node::MODE_DIR, name.to_str().unwrap(), parent_block) {
-            Ok(()) => {
-                reply.ok();
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn unlink(&mut self, _req: &Request, parent_block: u64, name: &Path, reply: ReplyEmpty) {
-        match self.fs.remove_node(redoxfs::Node::MODE_FILE, name.to_str().unwrap(), parent_block) {
-            Ok(()) => {
-                reply.ok();
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn statfs(&mut self, _req: &Request, _ino: u64, reply: ReplyStatfs) {
-        let free = self.fs.header.1.free;
-        match self.fs.node_len(free) {
-            Ok(free_size) => {
-                let bsize = 512;
-                let blocks = self.fs.header.1.size/bsize;
-                let bfree = free_size/bsize;
-                reply.statfs(blocks, bfree, bfree, 0, 0, bsize as u32, 256, 0);
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-
-    fn symlink(&mut self, _req: &Request, parent_block: u64, name: &Path, link: &Path, reply: ReplyEntry) {
-        let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-        match self.fs.create_node(redoxfs::Node::MODE_SYMLINK | 0o777, name.to_str().unwrap(), parent_block, ctime.as_secs(), ctime.subsec_nanos()) {
-            Ok(node) => {
-                let mtime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-                match self.fs.write_node(node.0, 0, link.as_os_str().as_bytes(), mtime.as_secs(), mtime.subsec_nanos()) {
-                    Ok(_count) => {
-                        reply.entry(&TTL, &node_attr(&node), 0);
-                    },
-                    Err(err) => {
-                        reply.error(err.errno as i32);
-                    }
-                }
-            },
-            Err(error) => {
-                reply.error(error.errno as i32);
-            }
-        }
-    }
-
-    fn readlink(&mut self, _req: &Request, ino: u64, reply: ReplyData) {
-        let mut data = vec![0; 4096];
-        match self.fs.read_node(ino, 0, &mut data) {
-            Ok(count) => {
-                reply.data(&data[..count]);
-            },
-            Err(err) => {
-                reply.error(err.errno as i32);
-            }
-        }
-    }
-}

mount/image.rs

-use std::fs::{File, OpenOptions};
-use std::io::{Read, Write, Seek, SeekFrom};
-
-use redoxfs::Disk;
-use syscall::error::{Error, Result, EIO};
-
-macro_rules! try_disk {
-    ($expr:expr) => (match $expr {
-        Ok(val) => val,
-        Err(err) => {
-            println!("Disk I/O Error: {}", err);
-            return Err(Error::new(EIO));
-        }
-    })
-}
-
-pub struct Image {
-    file: File
-}
-
-impl Image {
-    pub fn open(path: &str) -> Result<Image> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).open(path));
-        Ok(Image {
-            file: file
-        })
-    }
-
-    pub fn create(path: &str, size: u64) -> Result<Image> {
-        let file = try_disk!(OpenOptions::new().read(true).write(true).create(true).open(path));
-        try_disk!(file.set_len(size));
-        Ok(Image {
-            file: file
-        })
-    }
-}
-
-impl Disk for Image {
-    fn read_at(&mut self, block: u64, buffer: &mut [u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * 512)));
-        let count = try_disk!(self.file.read(buffer));
-        Ok(count)
-    }
-
-    fn write_at(&mut self, block: u64, buffer: &[u8]) -> Result<usize> {
-        try_disk!(self.file.seek(SeekFrom::Start(block * 512)));
-        let count = try_disk!(self.file.write(buffer));
-        Ok(count)
-    }
-
-    fn size(&mut self) -> Result<u64> {
-        let size = try_disk!(self.file.seek(SeekFrom::End(0)));
-        Ok(size)
-    }
-}

mount/main.rs

-#![deny(warnings)]
-#![cfg_attr(unix, feature(libc))]
-
-#[cfg(unix)]
-extern crate libc;
-
-extern crate redoxfs;
-extern crate syscall;
-
-use std::env;
-use std::fs::File;
-use std::os::unix::io::FromRawFd;
-use std::path::Path;
-use std::process;
-
-use cache::Cache;
-use image::Image;
-
-pub mod cache;
-pub mod image;
-
-#[cfg(unix)]
-pub mod fuse;
-
-#[cfg(target_os = "redox")]
-pub mod redox;
-
-#[cfg(unix)]
-fn fork() -> isize {
-    unsafe { libc::fork() as isize }
-}
-
-#[cfg(unix)]
-fn pipe(pipes: &mut [i32; 2]) -> isize {
-    unsafe { libc::pipe(pipes.as_mut_ptr()) as isize }
-}
-
-#[cfg(all(unix, target_os = "macos"))]
-fn mount<P: AsRef<Path>>(filesystem: redoxfs::FileSystem, mountpoint: &P, mut write: File) {
-    use std::ffi::OsStr;
-    use std::io::Write;
-
-    let _ = write.write(&[0]);
-    drop(write);
-
-    fuse::mount(fuse::Fuse {
-        fs: filesystem
-    }, mountpoint, &[
-        // One of the uses of this redoxfs fuse wrapper is to populate a filesystem
-        // while building the Redox OS kernel. This means that we need to write on
-        // a filesystem that belongs to `root`, which in turn means that we need to
-        // be `root`, thus that we need to allow `root` to have access.
-        OsStr::new("-o"),
-        OsStr::new("defer_permissions"),
-    ]);
-}
-
-#[cfg(all(unix, not(target_os = "macos")))]
-fn mount<P: AsRef<Path>>(filesystem: redoxfs::FileSystem, mountpoint: &P, mut write: File) {
-    use std::io::Write;
-
-    let _ = write.write(&[0]);
-    drop(write);
-
-    fuse::mount(fuse::Fuse {
-        fs: filesystem
-    }, mountpoint, &[]);
-}
-
-#[cfg(target_os = "redox")]
-fn fork() -> isize {
-    unsafe { syscall::Error::mux(syscall::clone(0)) as isize }
-}
-
-#[cfg(target_os = "redox")]
-fn pipe(pipes: &mut [usize; 2]) -> isize {
-    syscall::Error::mux(syscall::pipe2(pipes, 0)) as isize
-}
-
-#[cfg(target_os = "redox")]
-fn mount<P: AsRef<Path>>(filesystem: redoxfs::FileSystem, mountpoint: &P, write: File) {
-    redox::mount(filesystem, mountpoint, write);
-}
-
-fn usage() {
-    println!("redoxfs [disk] [mountpoint]");
-}
-
-fn main() {
-    use std::io::{Read, Write};
-
-    let mut pipes = [0; 2];
-    if pipe(&mut pipes) == 0 {
-        let mut read = unsafe { File::from_raw_fd(pipes[0]) };
-        let mut write = unsafe { File::from_raw_fd(pipes[1]) };
-
-        let pid = fork();
-        if pid == 0 {
-            drop(read);
-
-            if let Some(path) = env::args().nth(1) {
-                //Open an existing image
-                match Image::open(&path).map(|image| Cache::new(image)) {
-                    Ok(disk) => match redoxfs::FileSystem::open(Box::new(disk)) {
-                        Ok(filesystem) => {
-                            println!("redoxfs: opened filesystem {}", path);
-
-                            if let Some(mountpoint) = env::args_os().nth(2) {
-                                mount(filesystem, &mountpoint, write);
-                                process::exit(0);
-                            } else {
-                                println!("redoxfs: no mount point provided");
-                                usage();
-                            }
-                        },
-                        Err(err) => println!("redoxfs: failed to open filesystem {}: {}", path, err)
-                    },
-                    Err(err) => println!("redoxfs: failed to open image {}: {}", path, err)
-                }
-
-                let _ = write.write(&[1]);
-                drop(write);
-                process::exit(1);
-            } else {
-                println!("redoxfs: no disk image provided");
-                usage();
-            }
-        } else if pid > 0 {
-            drop(write);
-
-            let mut res = [0];
-            read.read(&mut res).unwrap();
-
-            process::exit(res[0] as i32);
-        } else {
-            panic!("redoxfs: failed to fork");
-        }
-    } else {
-        panic!("redoxfs: failed to create pipe");
-    }
-}

mount/redox/mod.rs

-extern crate spin;
-
-use redoxfs;
-use syscall::{Packet, Scheme};
-use std::fs::File;
-use std::io::{Read, Write};
-use std::path::Path;
-
-use self::scheme::FileScheme;
-
-pub mod resource;
-pub mod scheme;
-
-pub fn mount<P: AsRef<Path>>(filesystem: redoxfs::FileSystem, mountpoint: &P, mut write: File) {
-    let mountpoint = mountpoint.as_ref();
-    match File::create(format!(":{}", mountpoint.display())) {
-        Ok(mut socket) => {
-            println!("redoxfs: mounted filesystem on {}:", mountpoint.display());
-
-            let _ = write.write(&[0]);
-            drop(write);
-
-            let scheme = FileScheme::new(format!("{}", mountpoint.display()), filesystem);
-            loop {
-                let mut packet = Packet::default();
-                socket.read(&mut packet).unwrap();
-                scheme.handle(&mut packet);
-                socket.write(&packet).unwrap();
-            }
-        },
-        Err(err) => println!("redoxfs: failed to create {} scheme: {}", mountpoint.display(), err)
-    }
-}

mount/redox/resource.rs

-use redoxfs::FileSystem;
-
-use std::cmp::{min, max};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use syscall::data::TimeSpec;
-use syscall::error::{Error, Result, EBADF, EINVAL};
-use syscall::flag::{O_ACCMODE, O_RDONLY, O_WRONLY, O_RDWR, F_GETFL, F_SETFL};
-use syscall::{Stat, SEEK_SET, SEEK_CUR, SEEK_END};
-
-pub trait Resource {
-    fn dup(&self) -> Result<Box<Resource>>;
-    fn read(&mut self, buf: &mut [u8], fs: &mut FileSystem) -> Result<usize>;
-    fn write(&mut self, buf: &[u8], fs: &mut FileSystem) -> Result<usize>;
-    fn seek(&mut self, offset: usize, whence: usize, fs: &mut FileSystem) -> Result<usize>;
-    fn fcntl(&mut self, cmd: usize, arg: usize) -> Result<usize>;
-    fn path(&self, buf: &mut [u8]) -> Result<usize>;
-    fn stat(&self, _stat: &mut Stat, fs: &mut FileSystem) -> Result<usize>;
-    fn sync(&mut self) -> Result<usize>;
-    fn truncate(&mut self, len: usize, fs: &mut FileSystem) -> Result<usize>;
-    fn utimens(&mut self, times: &[TimeSpec], fs: &mut FileSystem) -> Result<usize>;
-}
-
-pub struct DirResource {
-    path: String,
-    block: u64,
-    data: Vec<u8>,
-    seek: usize,
-}
-
-impl DirResource {
-    pub fn new(path: String, block: u64, data: Vec<u8>) -> DirResource {
-        DirResource {
-            path: path,
-            block: block,
-            data: data,
-            seek: 0,
-        }
-    }
-}
-
-impl Resource for DirResource {
-    fn dup(&self) -> Result<Box<Resource>> {
-        Ok(Box::new(DirResource {
-            path: self.path.clone(),
-            block: self.block,
-            data: self.data.clone(),
-            seek: self.seek
-        }))
-    }
-
-    fn read(&mut self, buf: &mut [u8], _fs: &mut FileSystem) -> Result<usize> {
-        let mut i = 0;
-        while i < buf.len() && self.seek < self.data.len() {
-            buf[i] = self.data[self.seek];
-            i += 1;
-            self.seek += 1;
-        }
-        Ok(i)
-    }
-
-    fn write(&mut self, _buf: &[u8], _fs: &mut FileSystem) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    fn seek(&mut self, offset: usize, whence: usize, _fs: &mut FileSystem) -> Result<usize> {
-        self.seek = match whence {
-            SEEK_SET => max(0, min(self.data.len() as isize, offset as isize)) as usize,
-            SEEK_CUR => max(0, min(self.data.len() as isize, self.seek as isize + offset as isize)) as usize,
-            SEEK_END => max(0, min(self.data.len() as isize, self.data.len() as isize + offset as isize)) as usize,
-            _ => return Err(Error::new(EINVAL))
-        };
-
-        Ok(self.seek)
-    }
-
-    fn fcntl(&mut self, _cmd: usize, _arg: usize) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    fn path(&self, buf: &mut [u8]) -> Result<usize> {
-        let path = self.path.as_bytes();
-
-        let mut i = 0;
-        while i < buf.len() && i < path.len() {
-            buf[i] = path[i];
-            i += 1;
-        }
-
-        Ok(i)
-    }
-
-    fn stat(&self, stat: &mut Stat, fs: &mut FileSystem) -> Result<usize> {
-        let node = fs.node(self.block)?;
-
-        *stat = Stat {
-            st_dev: 0, // TODO
-            st_ino: node.0,
-            st_mode: node.1.mode,
-            st_nlink: 1,
-            st_uid: node.1.uid,
-            st_gid: node.1.gid,
-            st_size: fs.node_len(self.block)?,
-            st_mtime: node.1.mtime,
-            st_mtime_nsec: node.1.mtime_nsec,
-            st_ctime: node.1.ctime,
-            st_ctime_nsec: node.1.ctime_nsec,
-            ..Default::default()
-        };
-
-        Ok(0)
-    }
-
-    fn sync(&mut self) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    fn truncate(&mut self, _len: usize, _fs: &mut FileSystem) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-
-    fn utimens(&mut self, _times: &[TimeSpec], _fs: &mut FileSystem) -> Result<usize> {
-        Err(Error::new(EBADF))
-    }
-}
-
-pub struct FileResource {
-    path: String,
-    block: u64,
-    flags: usize,
-    seek: u64,
-}
-
-impl FileResource {
-    pub fn new(path: String, block: u64, flags: usize, seek: u64) -> FileResource {
-        FileResource {
-            path: path,
-            block: block,
-            flags: flags,
-            seek: seek,
-        }
-    }
-}
-
-impl Resource for FileResource {
-    fn dup(&self) -> Result<Box<Resource>> {
-        Ok(Box::new(FileResource {
-            path: self.path.clone(),
-            block: self.block,
-            flags: self.flags,
-            seek: self.seek,
-        }))
-    }
-
-    fn read(&mut self, buf: &mut [u8], fs: &mut FileSystem) -> Result<usize> {
-        if self.flags & O_ACCMODE == O_RDWR || self.flags & O_ACCMODE == O_RDONLY {
-            let count = fs.read_node(self.block, self.seek, buf)?;
-            self.seek += count as u64;
-            Ok(count)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn write(&mut self, buf: &[u8], fs: &mut FileSystem) -> Result<usize> {
-        if self.flags & O_ACCMODE == O_RDWR || self.flags & O_ACCMODE == O_WRONLY {
-            let mtime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-            let count = fs.write_node(self.block, self.seek, buf, mtime.as_secs(), mtime.subsec_nanos())?;
-            self.seek += count as u64;
-            Ok(count)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn seek(&mut self, offset: usize, whence: usize, fs: &mut FileSystem) -> Result<usize> {
-        let size = fs.node_len(self.block)?;
-
-        self.seek = match whence {
-            SEEK_SET => max(0, offset as i64) as u64,
-            SEEK_CUR => max(0, self.seek as i64 + offset as i64) as u64,
-            SEEK_END => max(0, size as i64 + offset as i64) as u64,
-            _ => return Err(Error::new(EINVAL))
-        };
-
-        Ok(self.seek as usize)
-    }
-
-    fn fcntl(&mut self, cmd: usize, arg: usize) -> Result<usize> {
-        match cmd {
-            F_GETFL => Ok(self.flags),
-            F_SETFL => {
-                self.flags = (self.flags & O_ACCMODE) | (arg & ! O_ACCMODE);
-                Ok(0)
-            },
-            _ => Err(Error::new(EINVAL))
-        }
-    }
-
-    fn path(&self, buf: &mut [u8]) -> Result<usize> {
-        let path = self.path.as_bytes();
-
-        let mut i = 0;
-        while i < buf.len() && i < path.len() {
-            buf[i] = path[i];
-            i += 1;
-        }
-
-        Ok(i)
-    }
-
-    fn stat(&self, stat: &mut Stat, fs: &mut FileSystem) -> Result<usize> {
-        let node = fs.node(self.block)?;
-
-        *stat = Stat {
-            st_dev: 0, // TODO
-            st_ino: node.0,
-            st_mode: node.1.mode,
-            st_nlink: 1,
-            st_uid: node.1.uid,
-            st_gid: node.1.gid,
-            st_size: fs.node_len(self.block)?,
-            st_mtime: node.1.mtime,
-            st_mtime_nsec: node.1.mtime_nsec,
-            st_ctime: node.1.ctime,
-            st_ctime_nsec: node.1.ctime_nsec,
-            ..Default::default()
-        };
-
-        Ok(0)
-    }
-
-    fn sync(&mut self) -> Result<usize> {
-        Ok(0)
-    }
-
-    fn truncate(&mut self, len: usize, fs: &mut FileSystem) -> Result<usize> {
-        if self.flags & O_ACCMODE == O_RDWR || self.flags & O_ACCMODE == O_WRONLY {
-            fs.node_set_len(self.block, len as u64)?;
-            Ok(0)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn utimens(&mut self, times: &[TimeSpec], fs: &mut FileSystem) -> Result<usize> {
-        if self.flags & O_ACCMODE == O_RDWR || self.flags & O_ACCMODE == O_WRONLY {
-            if let Some(mtime) = times.get(1) {
-                let mut node = fs.node(self.block)?;
-
-                node.1.mtime = mtime.tv_sec as u64;
-                node.1.mtime_nsec = mtime.tv_nsec as u32;
-
-                fs.write_at(node.0, &node.1)?;
-
-                Ok(0)
-            } else {
-                Ok(0)
-            }
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-}

mount/redox/scheme.rs

-use redox::resource::{Resource, DirResource, FileResource};
-use redox::spin::Mutex;
-
-use redoxfs::{FileSystem, Node};
-use std::cell::RefCell;
-use std::collections::BTreeMap;
-use std::str;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::time::{SystemTime, UNIX_EPOCH};
-
-use syscall::data::{Stat, StatVfs, TimeSpec};
-use syscall::error::{Error, Result, EACCES, EEXIST, EISDIR, ENOTDIR, EPERM, ENOENT, EBADF, ELOOP, EINVAL};
-use syscall::flag::{O_APPEND, O_CREAT, O_DIRECTORY, O_STAT, O_EXCL, O_TRUNC, O_ACCMODE, O_RDONLY, O_WRONLY, O_RDWR, MODE_PERM, O_SYMLINK, O_NOFOLLOW};
-use syscall::scheme::Scheme;
-
-pub struct FileScheme {
-    name: String,
-    fs: RefCell<FileSystem>,
-    next_id: AtomicUsize,
-    files: Mutex<BTreeMap<usize, Box<Resource>>>
-}
-
-impl FileScheme {
-    pub fn new(name: String, fs: FileSystem) -> FileScheme {
-        FileScheme {
-            name: name,
-            fs: RefCell::new(fs),
-            next_id: AtomicUsize::new(1),
-            files: Mutex::new(BTreeMap::new())
-        }
-    }
-}
-
-impl FileScheme {
-    fn resolve_symlink(&self, fs: &mut FileSystem, uid: u32, gid: u32, url: &[u8], node: (u64, Node), nodes: &mut Vec<(u64, Node)>) -> Result<Vec<u8>> {
-        let mut node = node;
-        for _ in 1..10 { // XXX What should the limit be?
-            let mut buf = [0; 4096];
-            let count = fs.read_node(node.0, 0, &mut buf)?;
-            let scheme = format!("{}:", &self.name);
-            let canon = canonicalize(&format!("{}{}", scheme, str::from_utf8(url).unwrap()).as_bytes(), &buf[0..count]);
-            let path = str::from_utf8(&canon[scheme.len()..]).unwrap_or("").trim_matches('/');
-            nodes.clear();
-            if let Some(next_node) = self.path_nodes(fs, path, uid, gid, nodes)? {
-                if !next_node.1.is_symlink() {
-                    if canon.starts_with(scheme.as_bytes()) {
-                        nodes.push(next_node);
-                        return Ok(canon[scheme.len()..].to_vec());
-                    } else {
-                        // TODO: Find way to support symlink to another scheme
-                        return Err(Error::new(ENOENT));
-                    }
-                }
-                node = next_node;
-            } else {
-                return Err(Error::new(ENOENT));
-            }
-        }
-        Err(Error::new(ELOOP))
-    }
-
-    fn path_nodes(&self, fs: &mut FileSystem, path: &str, uid: u32, gid: u32, nodes: &mut Vec<(u64, Node)>) -> Result<Option<(u64, Node)>> {
-        let mut parts = path.split('/').filter(|part| ! part.is_empty());
-        let mut part_opt = None;
-        let mut block = fs.header.1.root;
-        loop {
-            let node_res = match part_opt {
-                None => fs.node(block),
-                Some(part) => fs.find_node(part, block),
-            };
-
-            part_opt = parts.next();
-            if part_opt.is_some() {
-                let node = node_res?;
-                if ! node.1.permission(uid, gid, Node::MODE_EXEC) {
-                    return Err(Error::new(EACCES));
-                }
-                if node.1.is_symlink() {
-                    let mut url = Vec::new();
-                    url.extend_from_slice(self.name.as_bytes());
-                    url.push(b':');
-                    for i in nodes.iter() {
-                        url.push(b'/');
-                        url.extend_from_slice(&i.1.name);
-                    }
-                    self.resolve_symlink(fs, uid, gid, &url, node, nodes)?;
-                    block = nodes.last().unwrap().0;
-                } else if ! node.1.is_dir() {
-                    return Err(Error::new(ENOTDIR));
-                } else {
-                    block = node.0;
-                    nodes.push(node);
-                }
-            } else {
-                match node_res {
-                    Ok(node) => return Ok(Some(node)),
-                    Err(err) => match err.errno {
-                        ENOENT => return Ok(None),
-                        _ => return Err(err)
-                    }
-                }
-            }
-        }
-    }
-}
-
-/// Make a relative path absolute
-/// Given a cwd of "scheme:/path"
-/// This function will turn "foo" into "scheme:/path/foo"
-/// "/foo" will turn into "scheme:/foo"
-/// "bar:/foo" will be used directly, as it is already absolute
-pub fn canonicalize(current: &[u8], path: &[u8]) -> Vec<u8> {
-    // This function is modified from a version in the kernel
-    let mut canon = if path.iter().position(|&b| b == b':').is_none() {
-        let cwd = &current[0..current.iter().rposition(|x| *x == '/' as u8).unwrap_or(0)];
-
-        let mut canon = if !path.starts_with(b"/") {
-            let mut c = cwd.to_vec();
-            if ! c.ends_with(b"/") {
-                c.push(b'/');
-            }
-            c
-        } else {
-            cwd[..cwd.iter().position(|&b| b == b':').map_or(1, |i| i + 1)].to_vec()
-        };
-
-        canon.extend_from_slice(&path);
-        canon
-    } else {
-        path.to_vec()
-    };
-
-    // NOTE: assumes the scheme does not include anything like "../" or "./"
-    let mut result = {
-        let parts = canon.split(|&c| c == b'/')
-            .filter(|&part| part != b".")
-            .rev()
-            .scan(0, |nskip, part| {
-                if part == b"." {
-                    Some(None)
-                } else if part == b".." {
-                    *nskip += 1;
-                    Some(None)
-                } else {
-                    if *nskip > 0 {
-                        *nskip -= 1;
-                        Some(None)
-                    } else {
-                        Some(Some(part))
-                    }
-                }
-            })
-            .filter_map(|x| x)
-            .collect::<Vec<_>>();
-        parts
-            .iter()
-            .rev()
-            .fold(Vec::new(), |mut vec, &part| {
-                vec.extend_from_slice(part);
-                vec.push(b'/');
-                vec
-            })
-    };
-    result.pop(); // remove extra '/'
-
-    // replace with the root of the scheme if it's empty
-    if result.len() == 0 {
-        let pos = canon.iter()
-                        .position(|&b| b == b':')
-                        .map_or(canon.len(), |p| p + 1);
-        canon.truncate(pos);
-        canon
-    } else {
-        result
-    }
-}
-
-impl Scheme for FileScheme {
-    fn open(&self, url: &[u8], flags: usize, uid: u32, gid: u32) -> Result<usize> {
-        let path = str::from_utf8(url).unwrap_or("").trim_matches('/');
-
-        // println!("Open '{}' {:X}", path, flags);
-
-        let mut fs = self.fs.borrow_mut();
-
-        let mut nodes = Vec::new();
-        let node_opt = self.path_nodes(&mut fs, path, uid, gid, &mut nodes)?;
-        let resource: Box<Resource> = match node_opt {
-            Some(node) => if flags & (O_CREAT | O_EXCL) == O_CREAT | O_EXCL {
-                return Err(Error::new(EEXIST));
-            } else if node.1.is_dir() {
-                if flags & O_STAT != O_STAT && flags & O_DIRECTORY != O_DIRECTORY {
-                    // println!("{:X} & {:X}: EISDIR {}", flags, O_DIRECTORY, path);
-                    return Err(Error::new(EISDIR));
-                }
-
-                if flags & O_ACCMODE == O_RDONLY {
-                    if ! node.1.permission(uid, gid, Node::MODE_READ) {
-                        // println!("dir not readable {:o}", node.1.mode);
-                        return Err(Error::new(EACCES));
-                    }
-
-                    let mut children = Vec::new();
-                    fs.child_nodes(&mut children, node.0)?;
-
-                    let mut data = Vec::new();
-                    for child in children.iter() {
-                        if let Ok(name) = child.1.name() {
-                            if ! data.is_empty() {
-                                data.push(b'\n');
-                            }
-                            data.extend_from_slice(&name.as_bytes());
-                        }
-                    }
-
-                    Box::new(DirResource::new(path.to_string(), node.0, data))
-                } else if flags & O_STAT == O_STAT {
-                    Box::new(DirResource::new(path.to_string(), node.0, Vec::new()))
-                } else {
-                    // println!("dir not opened with O_RDONLY");
-                    return Err(Error::new(EACCES));
-                }
-            } else if node.1.is_symlink() && !(flags & O_STAT == O_STAT && flags  & O_NOFOLLOW == O_NOFOLLOW) && flags & O_SYMLINK != O_SYMLINK {
-                let mut resolve_nodes = Vec::new();
-                let resolved = self.resolve_symlink(&mut fs, uid, gid, url, node, &mut resolve_nodes)?;
-                drop(fs);
-                return self.open(&resolved, flags, uid, gid);
-            } else if !node.1.is_symlink() && flags & O_SYMLINK == O_SYMLINK {
-                  return Err(Error::new(EINVAL));
-            } else {
-                if flags & O_DIRECTORY == O_DIRECTORY {
-                    // println!("{:X} & {:X}: ENOTDIR {}", flags, O_DIRECTORY, path);
-                    return Err(Error::new(ENOTDIR));
-                }
-
-                if (flags & O_ACCMODE == O_RDONLY || flags & O_ACCMODE == O_RDWR) && ! node.1.permission(uid, gid, Node::MODE_READ) {
-                    // println!("file not readable {:o}", node.1.mode);
-                    return Err(Error::new(EACCES));
-                }
-
-                if (flags & O_ACCMODE == O_WRONLY || flags & O_ACCMODE == O_RDWR) && ! node.1.permission(uid, gid, Node::MODE_WRITE) {
-                    // println!("file not writable {:o}", node.1.mode);
-                    return Err(Error::new(EACCES));
-                }
-
-                if flags & O_TRUNC == O_TRUNC {
-                    if ! node.1.permission(uid, gid, Node::MODE_WRITE) {
-                        // println!("file not writable {:o}", node.1.mode);
-                        return Err(Error::new(EACCES));
-                    }
-
-                    fs.node_set_len(node.0, 0)?;
-                }
-
-                let seek = if flags & O_APPEND == O_APPEND {
-                    fs.node_len(node.0)?
-                } else {
-                    0
-                };
-
-                Box::new(FileResource::new(path.to_string(), node.0, flags, seek))
-            },
-            None => if flags & O_CREAT == O_CREAT {
-                let mut last_part = String::new();
-                for part in path.split('/') {
-                    if ! part.is_empty() {
-                        last_part = part.to_string();
-                    }
-                }
-                if ! last_part.is_empty() {
-                    if let Some(parent) = nodes.last() {
-                        if ! parent.1.permission(uid, gid, Node::MODE_WRITE) {
-                            // println!("dir not writable {:o}", parent.1.mode);
-                            return Err(Error::new(EACCES));
-                        }
-
-                        let dir = flags & O_DIRECTORY == O_DIRECTORY;
-                        let mode_type = if dir {
-                            Node::MODE_DIR
-                        } else if flags & O_SYMLINK == O_SYMLINK {
-                            Node::MODE_SYMLINK
-                        } else {
-                            Node::MODE_FILE
-                        };
-
-                        let ctime = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
-                        let mut node = fs.create_node(mode_type | (flags as u16 & Node::MODE_PERM), &last_part, parent.0, ctime.as_secs(), ctime.subsec_nanos())?;
-                        node.1.uid = uid;
-                        node.1.gid = gid;
-                        fs.write_at(node.0, &node.1)?;
-
-                        if dir {
-                            Box::new(DirResource::new(path.to_string(), node.0, Vec::new()))
-                        } else {
-                            let seek = if flags & O_APPEND == O_APPEND {
-                                fs.node_len(node.0)?
-                            } else {
-                                0
-                            };
-
-                            Box::new(FileResource::new(path.to_string(), node.0, flags, seek))
-                        }
-                    } else {
-                        return Err(Error::new(EPERM));
-                    }
-                } else {
-                    return Err(Error::new(EPERM));
-                }
-            } else {
-                return Err(Error::new(ENOENT));
-            }
-        };
-
-        let id = self.next_id.fetch_add(1, Ordering::SeqCst);
-        self.files.lock().insert(id, resource);
-
-        Ok(id)
-    }
-
-    fn chmod(&self, url: &[u8], mode: u16, uid: u32, gid: u32) -> Result<usize> {
-        let path = str::from_utf8(url).unwrap_or("").trim_matches('/');
-
-        // println!("Chmod '{}'", path);
-
-        let mut fs = self.fs.borrow_mut();
-
-        let mut nodes = Vec::new();
-        if let Some(mut node) = self.path_nodes(&mut fs, path, uid, gid, &mut nodes)? {
-            if node.1.uid == uid || uid == 0 {
-                node.1.mode = (node.1.mode & ! MODE_PERM) | (mode & MODE_PERM);
-                fs.write_at(node.0, &node.1)?;
-                Ok(0)
-            } else {
-                Err(Error::new(EPERM))
-            }
-        } else {
-            Err(Error::new(ENOENT))
-        }
-    }
-
-    fn rmdir(&self, url: &[u8], uid: u32, gid: u32) -> Result<usize> {
-        let path = str::from_utf8(url).unwrap_or("").trim_matches('/');
-
-        // println!("Rmdir '{}'", path);
-
-        let mut fs = self.fs.borrow_mut();
-
-        let mut nodes = Vec::new();
-        if let Some(child) = self.path_nodes(&mut fs, path, uid, gid, &mut nodes)? {
-            if let Some(parent) = nodes.last() {
-                if ! parent.1.permission(uid, gid, Node::MODE_WRITE) {
-                    // println!("dir not writable {:o}", parent.1.mode);
-                    return Err(Error::new(EACCES));
-                }
-
-                if child.1.is_dir() {
-                    if ! child.1.permission(uid, gid, Node::MODE_WRITE) {
-                        // println!("dir not writable {:o}", parent.1.mode);
-                        return Err(Error::new(EACCES));
-                    }
-
-                    if let Ok(child_name) = child.1.name() {
-                        fs.remove_node(Node::MODE_DIR, child_name, parent.0).and(Ok(0))
-                    } else {
-                        Err(Error::new(ENOENT))
-                    }
-                } else {
-                    Err(Error::new(ENOTDIR))
-                }
-            } else {
-                Err(Error::new(EPERM))
-            }
-        } else {
-            Err(Error::new(ENOENT))
-        }
-    }
-
-    fn unlink(&self, url: &[u8], uid: u32, gid: u32) -> Result<usize> {
-        let path = str::from_utf8(url).unwrap_or("").trim_matches('/');
-
-        // println!("Unlink '{}'", path);
-
-        let mut fs = self.fs.borrow_mut();
-
-        let mut nodes = Vec::new();
-        if let Some(child) = self.path_nodes(&mut fs, path, uid, gid, &mut nodes)? {
-            if let Some(parent) = nodes.last() {
-                if ! parent.1.permission(uid, gid, Node::MODE_WRITE) {
-                    // println!("dir not writable {:o}", parent.1.mode);
-                    return Err(Error::new(EACCES));
-                }
-
-                if ! child.1.is_dir() {
-                    if child.1.uid != uid {
-                        // println!("file not owned by current user {}", parent.1.uid);
-                        return Err(Error::new(EACCES));
-                    }
-
-                    if let Ok(child_name) = child.1.name() {
-                        if child.1.is_symlink() {
-                            fs.remove_node(Node::MODE_SYMLINK, child_name, parent.0).and(Ok(0))
-                        } else {
-                            fs.remove_node(Node::MODE_FILE, child_name, parent.0).and(Ok(0))
-                        }
-                    } else {
-                        Err(Error::new(ENOENT))
-                    }
-                } else {
-                    Err(Error::new(EISDIR))
-                }
-            } else {
-                Err(Error::new(EPERM))
-            }
-        } else {
-            Err(Error::new(ENOENT))
-        }
-    }
-
-    /* Resource operations */
-    #[allow(unused_variables)]
-    fn dup(&self, old_id: usize, buf: &[u8]) -> Result<usize> {
-        // println!("Dup {}", old_id);
-
-        if ! buf.is_empty() {
-            return Err(Error::new(EINVAL));
-        }
-
-        let mut files = self.files.lock();
-        let resource = if let Some(old_resource) = files.get(&old_id) {
-            old_resource.dup()?
-        } else {
-            return Err(Error::new(EBADF));
-        };
-
-        let id = self.next_id.fetch_add(1, Ordering::SeqCst);
-        files.insert(id, resource);
-
-        Ok(id)
-    }
-
-    #[allow(unused_variables)]
-    fn read(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
-        // println!("Read {}, {:X} {}", id, buf.as_ptr() as usize, buf.len());
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.read(buf, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn write(&self, id: usize, buf: &[u8]) -> Result<usize> {
-        // println!("Write {}, {:X} {}", id, buf.as_ptr() as usize, buf.len());
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.write(buf, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn seek(&self, id: usize, pos: usize, whence: usize) -> Result<usize> {
-        // println!("Seek {}, {} {}", id, pos, whence);
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.seek(pos, whence, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn fcntl(&self, id: usize, cmd: usize, arg: usize) -> Result<usize> {
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.fcntl(cmd, arg)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn fpath(&self, id: usize, buf: &mut [u8]) -> Result<usize> {
-        // println!("Fpath {}, {:X} {}", id, buf.as_ptr() as usize, buf.len());
-        let files = self.files.lock();
-        if let Some(file) = files.get(&id) {
-            let name = self.name.as_bytes();
-
-            let mut i = 0;
-            while i < buf.len() && i < name.len() {
-                buf[i] = name[i];
-                i += 1;
-            }
-            if i < buf.len() {
-                buf[i] = b':';
-                i += 1;
-            }
-            if i < buf.len() {
-                buf[i] = b'/';
-                i += 1;
-            }
-
-            file.path(&mut buf[i..]).map(|count| i + count)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn fstat(&self, id: usize, stat: &mut Stat) -> Result<usize> {
-        // println!("Fstat {}, {:X}", id, stat as *mut Stat as usize);
-        let files = self.files.lock();
-        if let Some(file) = files.get(&id) {
-            file.stat(stat, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn fstatvfs(&self, id: usize, stat: &mut StatVfs) -> Result<usize> {
-        let files = self.files.lock();
-        if let Some(_file) = files.get(&id) {
-            let mut fs = self.fs.borrow_mut();
-
-            let free = fs.header.1.free;
-            let free_size = fs.node_len(free)?;
-
-            stat.f_bsize = 512;
-            stat.f_blocks = fs.header.1.size/(stat.f_bsize as u64);
-            stat.f_bfree = free_size/(stat.f_bsize as u64);
-            stat.f_bavail = stat.f_bfree;
-
-            Ok(0)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn fsync(&self, id: usize) -> Result<usize> {
-        // println!("Fsync {}", id);
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.sync()
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn ftruncate(&self, id: usize, len: usize) -> Result<usize> {
-        // println!("Ftruncate {}, {}", id, len);
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.truncate(len, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn futimens(&self, id: usize, times: &[TimeSpec]) -> Result<usize> {
-        // println!("Futimens {}, {}", id, times.len());
-        let mut files = self.files.lock();
-        if let Some(mut file) = files.get_mut(&id) {
-            file.utimens(times, &mut self.fs.borrow_mut())
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-
-    fn close(&self, id: usize) -> Result<usize> {
-        // println!("Close {}", id);
-        let mut files = self.files.lock();
-        if files.remove(&id).is_some() {
-            Ok(0)
-        } else {
-            Err(Error::new(EBADF))
-        }
-    }
-}