From 324b4ccdb12d5eac175aee2dc03373eb129229d5 Mon Sep 17 00:00:00 2001 From: Dario Gonzalez Date: Mon, 6 Jan 2020 17:03:58 -0800 Subject: [PATCH 1/4] initial work porting to tokio 0.2 --- Cargo.lock | 436 ++++++++++++----------- enclave-runner/Cargo.toml | 5 +- enclave-runner/src/lib.rs | 1 - enclave-runner/src/library.rs | 9 +- enclave-runner/src/usercalls/mod.rs | 470 ++++++++++++------------- sgxs-tools/src/sgx_detect/tests/mod.rs | 2 +- 6 files changed, 464 insertions(+), 459 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 94f2485b..2ad1b807 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,11 +36,11 @@ dependencies = [ [[package]] name = "aho-corasick" -version = "0.7.8" +version = "0.7.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "743ad5a418686aad3b87fd14c43badd828cf26e214a00f92a384291cf22e1811" +checksum = "8716408b8bc624ed7f65d223ddb9ac2d044c0547b6fa4b0d554f3a9540496ada" dependencies = [ - "memchr 2.3.0", + "memchr 2.3.3", ] [[package]] @@ -52,6 +52,12 @@ dependencies = [ "winapi 0.3.8", ] +[[package]] +name = "arc-swap" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d663a8e9a99154b5fb793032533f6328da35e23aac63d5c152279aa8ba356825" + [[package]] name = "atty" version = "0.2.14" @@ -77,9 +83,9 @@ checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d" [[package]] name = "backtrace" -version = "0.3.43" +version = "0.3.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f80256bc78f67e7df7e36d77366f636ed976895d91fe2ab9efa3973e8fe8c4f" +checksum = "ad235dabf00f36301792cfe82499880ba54c6486be094d1047b02bacb67c14e8" dependencies = [ "backtrace-sys", "cfg-if", @@ -89,9 +95,9 @@ dependencies = [ [[package]] name = "backtrace-sys" -version = "0.1.32" +version = "0.1.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d6575f128516de27e3ce99689419835fce9643a9b215a14d2b5b685be018491" +checksum = "ca797db0057bae1a7aa2eef3283a874695455cecf08a43bfb8507ee0ebc1ed69" dependencies = [ "cc", "libc", @@ -197,13 +203,10 @@ dependencies = [ ] [[package]] -name = "c2-chacha" -version = "0.2.3" +name = "bytes" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "214238caa1bf3a496ec3392968969cab8549f96ff30652c9e56885329315f6bb" -dependencies = [ - "ppv-lite86", -] +checksum = "130aac562c0dd69c56b3b1cc8ffd2e17be31d0b6c25b61c96b76231aa23e39e1" [[package]] name = "cc" @@ -290,9 +293,9 @@ dependencies = [ [[package]] name = "compiler_builtins" -version = "0.1.24" +version = "0.1.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9975aefa63997ef75ca9cf013ff1bb81487aaa0b622c21053afd3b92979a7af" +checksum = "036b035e9ebcd705affece16319223d19f229e2358be6e3b7b094e57193312e6" dependencies = [ "rustc-std-workspace-core", ] @@ -327,9 +330,9 @@ dependencies = [ [[package]] name = "core-foundation" -version = "0.6.4" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25b9e03f145fd4f2bf705e07b900cd41fc636598fe5dc452fd0db1441c3f496d" +checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171" dependencies = [ "core-foundation-sys", "libc", @@ -337,9 +340,9 @@ dependencies = [ [[package]] name = "core-foundation-sys" -version = "0.6.2" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7ca8a5221364ef15ce201e8ed2f609fc312682a8f4e0e3d4aa5879764e0fa3b" +checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac" [[package]] name = "crc32fast" @@ -366,33 +369,36 @@ dependencies = [ [[package]] name = "crossbeam-channel" -version = "0.4.0" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "acec9a3b0b3559f15aee4f90746c4e5e293b701c0f7d3925d24e01645267b68c" +checksum = "cced8691919c02aac3cb0a1bc2e9b73d89e832bf9a06fc579d4e71b68a2da061" dependencies = [ "crossbeam-utils", + "maybe-uninit", ] [[package]] name = "crossbeam-deque" -version = "0.7.2" +version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3aa945d63861bfe624b55d153a39684da1e8c0bc8fba932f7ee3a3c16cea3ca" +checksum = "9f02af974daeee82218205558e51ec8768b48cf524bd01d550abe5573a608285" dependencies = [ "crossbeam-epoch", "crossbeam-utils", + "maybe-uninit", ] [[package]] name = "crossbeam-epoch" -version = "0.8.0" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5064ebdbf05ce3cb95e45c8b086f72263f4166b29b97f6baff7ef7fe047b55ac" +checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace" dependencies = [ - "autocfg 0.1.7", + "autocfg 1.0.0", "cfg-if", "crossbeam-utils", "lazy_static 1.4.0", + "maybe-uninit", "memoffset", "scopeguard", ] @@ -409,11 +415,11 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.7.0" +version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce446db02cdc3165b94ae73111e570793400d0794e46125cc4056c81cbb039f4" +checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" dependencies = [ - "autocfg 0.1.7", + "autocfg 1.0.0", "cfg-if", "lazy_static 1.4.0", ] @@ -521,8 +527,7 @@ dependencies = [ "openssl", "sgx-isa", "sgxs", - "tokio", - "tokio-io", + "tokio 0.2.13", ] [[package]] @@ -553,24 +558,24 @@ dependencies = [ "atty", "humantime", "log 0.4.8", - "regex 1.3.4", + "regex 1.3.5", "termcolor", ] [[package]] name = "error-chain" -version = "0.12.1" +version = "0.12.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ab49e9dcb602294bc42f9a7dfc9bc6e936fca4418ea300dbfb84fe16de0b7d9" +checksum = "d371106cc88ffdfb1eabd7111e432da544f16f3e2d7bf1dfe8bf575f1df045cd" dependencies = [ - "version_check 0.1.5", + "version_check", ] [[package]] name = "failure" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8273f13c977665c5db7eb2b99ae520952fe5ac831ae4cd09d80c4c7042b5ed9" +checksum = "b8529c2421efa3066a5cbd8063d2244603824daccb6936b079010bb2aa89464b" dependencies = [ "backtrace", "failure_derive", @@ -578,13 +583,13 @@ dependencies = [ [[package]] name = "failure_derive" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bc225b78e0391e4b8683440bf2e63c2deeeb2ce5189eab46e2b68c6d3725d08" +checksum = "030a733c8287d6213886dd487564ff5c8f6aae10278b3588ed177f9d18f8d231" dependencies = [ - "proc-macro2 1.0.8", - "quote 1.0.2", - "syn 1.0.14", + "proc-macro2 1.0.9", + "quote 1.0.3", + "syn 1.0.17", "synstructure", ] @@ -602,9 +607,9 @@ checksum = "86d4de0081402f5e88cdac65c8dcdcc73118c1a7a465e2a05f0da05843a8ea33" [[package]] name = "flate2" -version = "1.0.13" +version = "1.0.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6bd6d6f4752952feb71363cffc9ebac9411b75b87c6ab6058c40c8900cf43c0f" +checksum = "2cfff41391129e0a856d6d822600b8d71179d46879e310417eb9c762eb178b42" dependencies = [ "cfg-if", "crc32fast", @@ -753,9 +758,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9a5081aa3de1f7542a794a397cde100ed903b0630152d0973479018fd85423a7" dependencies = [ "proc-macro-hack", - "proc-macro2 1.0.8", - "quote 1.0.2", - "syn 1.0.14", + "proc-macro2 1.0.9", + "quote 1.0.3", + "syn 1.0.17", ] [[package]] @@ -783,7 +788,7 @@ dependencies = [ "futures-macro", "futures-sink", "futures-task", - "memchr 2.3.0", + "memchr 2.3.3", "pin-utils", "proc-macro-hack", "proc-macro-nested", @@ -824,7 +829,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a5b34c246847f938a410a03c5458c7fee2274436675e76d8b903c08efc29c462" dependencies = [ "byteorder", - "bytes", + "bytes 0.4.12", "fnv", "futures 0.1.29", "http", @@ -837,9 +842,9 @@ dependencies = [ [[package]] name = "hermit-abi" -version = "0.1.6" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eff2656d88f158ce120947499e971d743c05dbcbed62e5bd2f38f1698bbc3772" +checksum = "1010591b26bbfe835e9faeabeb11866061cc7dcebffd56ad7d0942d0e61aefd8" dependencies = [ "libc", ] @@ -856,7 +861,7 @@ version = "0.1.21" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6ccf5ede3a895d8856620237b2f02972c1bbc78d2965ad7fe8838d4a0ed41f0" dependencies = [ - "bytes", + "bytes 0.4.12", "fnv", "itoa", ] @@ -867,7 +872,7 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6741c859c1b2463a423a1dbce98d418e6c3c3fc720fb0d45528657320920292d" dependencies = [ - "bytes", + "bytes 0.4.12", "futures 0.1.29", "http", "tokio-buf", @@ -894,7 +899,7 @@ version = "0.12.35" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9dbe6ed1438e1f8ad955a4701e9a944938e9519f6888d12d8558b645e247d5f6" dependencies = [ - "bytes", + "bytes 0.4.12", "futures 0.1.29", "futures-cpupool", "h2", @@ -907,7 +912,7 @@ dependencies = [ "net2", "rustc_version", "time", - "tokio", + "tokio 0.1.22", "tokio-buf", "tokio-executor", "tokio-io", @@ -924,7 +929,7 @@ version = "0.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3a800d6aa50af4b5850b2b0f659625ce9504df908e9733b635720483be26174f" dependencies = [ - "bytes", + "bytes 0.4.12", "futures 0.1.29", "hyper", "native-tls", @@ -1001,9 +1006,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.66" +version = "0.2.68" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d515b1f41455adea1313a4a2ac8a8a477634fbae63cc6100e3aebb207ce61558" +checksum = "dea0c0405123bba743ee3f91f49b1c7cfb684eef0da0a50110f758ccf24cdff0" [[package]] name = "libloading" @@ -1062,9 +1067,9 @@ checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" [[package]] name = "mbedtls" -version = "0.5.1" +version = "0.5.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c662251d308dfeaf331db82be4d152d776236474111ca65c4536e33f5040ccb" +checksum = "4abf3e5f6fe208c3788524a645c5a18ce287f43db94ee98396a9c9460e27f5be" dependencies = [ "bitflags 1.2.1", "byteorder", @@ -1078,9 +1083,9 @@ dependencies = [ [[package]] name = "mbedtls-sys-auto" -version = "2.18.2" +version = "2.18.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "566c55bba442fc191d4117c92d2018fa129e1b8b8a10f266c5cb3766531941c1" +checksum = "5bd039b35fb53517355001b0e2ac010202f5f4264f69d1929b6de83b9353294c" dependencies = [ "bindgen", "cmake", @@ -1106,17 +1111,17 @@ dependencies = [ [[package]] name = "memchr" -version = "2.3.0" +version = "2.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3197e20c7edb283f87c071ddfc7a2cca8f8e0b888c242959846a6fce03c72223" +checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" [[package]] name = "memoffset" -version = "0.5.3" +version = "0.5.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75189eb85871ea5c2e2c15abbdd541185f63b408415e5051f5cac122d8c774b9" +checksum = "b4fc2c02a7e374099d4ee95a193111f72d2110197fe200272371758f6c3643d8" dependencies = [ - "rustc_version", + "autocfg 1.0.0", ] [[package]] @@ -1127,9 +1132,9 @@ checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d" [[package]] name = "mime_guess" -version = "2.0.1" +version = "2.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a0ed03949aef72dbdf3116a383d7b38b4768e6f960528cd6a6044aa9ed68599" +checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212" dependencies = [ "mime", "unicase", @@ -1157,12 +1162,24 @@ dependencies = [ "kernel32-sys", "libc", "log 0.4.8", - "miow", + "miow 0.2.1", "net2", "slab", "winapi 0.2.8", ] +[[package]] +name = "mio-named-pipes" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5e374eff525ce1c5b7687c4cef63943e7686524a387933ad27ca7ec43779cb3" +dependencies = [ + "log 0.4.8", + "mio", + "miow 0.3.3", + "winapi 0.3.8", +] + [[package]] name = "mio-uds" version = "0.6.7" @@ -1186,6 +1203,16 @@ dependencies = [ "ws2_32-sys", ] +[[package]] +name = "miow" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "396aa0f2003d7df8395cb93e09871561ccc3e785f0acb369170e8cc74ddf9226" +dependencies = [ + "socket2", + "winapi 0.3.8", +] + [[package]] name = "mopa" version = "0.2.2" @@ -1194,9 +1221,9 @@ checksum = "a785740271256c230f57462d3b83e52f998433a7062fc18f96d5999474a9f915" [[package]] name = "native-tls" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b2df1a4c22fd44a62147fd8f13dd0f95c9d8ca7b2610299b2a2f9cf8964274e" +checksum = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d" dependencies = [ "lazy_static 1.4.0", "libc", @@ -1325,9 +1352,9 @@ dependencies = [ [[package]] name = "num-rational" -version = "0.2.3" +version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da4dc79f9e6c81bef96148c8f6b8e72ad4541caa4a24373e900a36da07de03a3" +checksum = "5c000134b5dbf44adc5cb772486d335293351644b801551abe8f75c84cfa4aef" dependencies = [ "autocfg 1.0.0", "num-bigint", @@ -1456,6 +1483,12 @@ dependencies = [ "ordermap", ] +[[package]] +name = "pin-project-lite" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "237844750cfbb86f67afe27eee600dfbbcb6188d734139b534cbfbf4f96792ae" + [[package]] name = "pin-utils" version = "0.1.0-alpha.4" @@ -1476,20 +1509,15 @@ checksum = "74490b50b9fbe561ac330df47c08f3f33073d2d00c150f719147d7c54522fa1b" [[package]] name = "proc-macro-hack" -version = "0.5.11" +version = "0.5.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ecd45702f76d6d3c75a80564378ae228a85f0b59d2f3ed43c91b4a69eb2ebfc5" -dependencies = [ - "proc-macro2 1.0.8", - "quote 1.0.2", - "syn 1.0.14", -] +checksum = "fcfdefadc3d57ca21cf17990a28ef4c0f7c61383a28cb7604cf4a18e6ede1420" [[package]] name = "proc-macro-nested" -version = "0.1.3" +version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "369a6ed065f249a159e06c45752c780bda2fb53c995718f9e484d08daa9eb42e" +checksum = "8e946095f9d3ed29ec38de908c22f95d9ac008e424c7bcae54c75a79c527c694" [[package]] name = "proc-macro2" @@ -1502,42 +1530,42 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.8" +version = "1.0.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3acb317c6ff86a4e579dfa00fc5e6cca91ecbb4e7eb2df0468805b674eb88548" +checksum = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435" dependencies = [ "unicode-xid 0.2.0", ] [[package]] name = "protobuf" -version = "2.10.1" +version = "2.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6686ddd96a8dbe2687b5f2a687b2cfb520854010ec480f2d74c32e7c9873d3c5" +checksum = "37a5325d019a4d837d3abde0a836920f959e33d350f77b5f1e289e061e774942" [[package]] name = "protobuf-codegen" -version = "2.10.1" +version = "2.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6456421eecf7fc72905868cd760c3e35848ded3552e480cfe67726ed4dbd8d23" +checksum = "64dd3a6192e0c6c1b0dae8f125b7f6b201c39fc487ebda0ee717d7a87fc47dc2" dependencies = [ "protobuf", ] [[package]] name = "protoc" -version = "2.10.1" +version = "2.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fd83d2547a9e2c8bc6016607281b3ec7ef4871c55be6930915481d80350ab88" +checksum = "8f89b56360a99c36ff8dcf7cc969b291fbae680b027e768bfd27110606f45271" dependencies = [ "log 0.4.8", ] [[package]] name = "protoc-rust" -version = "2.10.1" +version = "2.10.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30fe03ab363474c2f5d1062f5d169ba8defd1d30c161261d7c71afd8412727d8" +checksum = "14600264b715f826e9d8e23a320bf56d3c8bc91eac533146f24a186d082a3889" dependencies = [ "protobuf", "protobuf-codegen", @@ -1554,7 +1582,7 @@ dependencies = [ "error-chain", "idna 0.2.0", "lazy_static 1.4.0", - "regex 1.3.4", + "regex 1.3.5", "url 2.1.1", ] @@ -1575,11 +1603,11 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "053a8c8bcc71fcce321828dc897a98ab9760bef03a4fc36693c231e5b3216cfe" +checksum = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f" dependencies = [ - "proc-macro2 1.0.8", + "proc-macro2 1.0.9", ] [[package]] @@ -1609,7 +1637,7 @@ checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom", "libc", - "rand_chacha 0.2.1", + "rand_chacha 0.2.2", "rand_core 0.5.1", "rand_hc 0.2.0", ] @@ -1626,11 +1654,11 @@ dependencies = [ [[package]] name = "rand_chacha" -version = "0.2.1" +version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "03a2a90da8c7523f554344f921aa97283eadf6ac484a6d2a7d0212fa7f8d6853" +checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" dependencies = [ - "c2-chacha", + "ppv-lite86", "rand_core 0.5.1", ] @@ -1759,13 +1787,13 @@ dependencies = [ [[package]] name = "regex" -version = "1.3.4" +version = "1.3.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "322cf97724bea3ee221b78fe25ac9c46114ebb51747ad5babd51a2fc6a8235a8" +checksum = "8900ebc1363efa7ea1c399ccc32daed870b4002651e0bed86e72d501ebbe0048" dependencies = [ - "aho-corasick 0.7.8", - "memchr 2.3.0", - "regex-syntax 0.6.14", + "aho-corasick 0.7.10", + "memchr 2.3.3", + "regex-syntax 0.6.17", "thread_local 1.0.1", ] @@ -1777,9 +1805,9 @@ checksum = "f9ec002c35e86791825ed294b50008eea9ddfc8def4420124fbc6b08db834957" [[package]] name = "regex-syntax" -version = "0.6.14" +version = "0.6.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b28dfe3fe9badec5dbf0a79a9cccad2cfc2ab5484bdb3e44cbd1ae8b3ba2be06" +checksum = "7fe5bd57d1d7414c6b5ed48563a2c855d995ff777729dcd91c369ec7fea395ae" [[package]] name = "remove_dir_all" @@ -1807,7 +1835,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f88643aea3c1343c804950d7bf983bd2067f5ab59db6d613a08e05572f2714ab" dependencies = [ "base64", - "bytes", + "bytes 0.4.12", "cookie", "cookie_store", "encoding_rs", @@ -1824,7 +1852,7 @@ dependencies = [ "serde_json", "serde_urlencoded", "time", - "tokio", + "tokio 0.1.22", "tokio-executor", "tokio-io", "tokio-threadpool", @@ -1879,15 +1907,15 @@ dependencies = [ [[package]] name = "ryu" -version = "1.0.2" +version = "1.0.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa8506c1de11c9c4e4c38863ccbe02a305c8188e85a05a784c9e11e1c3910c8" +checksum = "535622e6be132bccd223f4bb2b8ac8d53cda3c7a6394944d3b2b33fb974f9d76" [[package]] name = "schannel" -version = "0.1.17" +version = "0.1.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "507a9e6e8ffe0a4e0ebb9a10293e62fdf7657c06f1b8bb07a8fcf697d2abf295" +checksum = "039c25b130bd8c1321ee2d7de7fde2659fa9c2744e4bb29711cfc852ea53cd19" dependencies = [ "lazy_static 1.4.0", "winapi 0.3.8", @@ -1895,29 +1923,30 @@ dependencies = [ [[package]] name = "scopeguard" -version = "1.0.0" +version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42e15e59b18a828bbf5c58ea01debb36b9b096346de35d941dcb89009f24a0d" +checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "security-framework" -version = "0.3.4" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ef2429d7cefe5fd28bd1d2ed41c944547d4ff84776f5935b456da44593a16df" +checksum = "97bbedbe81904398b6ebb054b3e912f99d55807125790f3198ac990d98def5b0" dependencies = [ + "bitflags 1.2.1", "core-foundation", "core-foundation-sys", - "libc", "security-framework-sys", ] [[package]] name = "security-framework-sys" -version = "0.3.3" +version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e31493fc37615debb8c5090a7aeb4a9730bc61e77ab10b9af59f1a202284f895" +checksum = "06fd2f23e31ef68dd2328cc383bd493142e46107a3a0e24f7d734e3f3b80fe4c" dependencies = [ "core-foundation-sys", + "libc", ] [[package]] @@ -1937,29 +1966,29 @@ checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3" [[package]] name = "serde" -version = "1.0.104" +version = "1.0.105" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "414115f25f818d7dfccec8ee535d76949ae78584fc4f79a6f45a904bf8ab4449" +checksum = "e707fbbf255b8fc8c3b99abb91e7257a622caeb20a9818cbadbeeede4e0932ff" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.104" +version = "1.0.105" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "128f9e303a5a29922045a830221b8f78ec74a5f544944f3d5984f8ec3895ef64" +checksum = "ac5d00fc561ba2724df6758a17de23df5914f20e41cb00f94d5b7ae42fffaff8" dependencies = [ - "proc-macro2 1.0.8", - "quote 1.0.2", - "syn 1.0.14", + "proc-macro2 1.0.9", + "quote 1.0.3", + "syn 1.0.17", ] [[package]] name = "serde_json" -version = "1.0.47" +version = "1.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15913895b61e0be854afd32fd4163fcd2a3df34142cf2cb961b310ce694cbf90" +checksum = "9371ade75d4c2d6cb154141b9752cf3781ec9c05e0e5cf35060e1e70ee7b9c25" dependencies = [ "itoa", "ryu", @@ -2055,7 +2084,7 @@ dependencies = [ "petgraph", "proc-macro2 0.4.30", "quote 0.6.13", - "regex 1.3.4", + "regex 1.3.5", "report-test", "reqwest", "serde", @@ -2081,6 +2110,16 @@ dependencies = [ "opaque-debug", ] +[[package]] +name = "signal-hook-registry" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f478ede9f64724c5d173d7bb56099ec3e2d9fc2774aac65d34b8b890405f41" +dependencies = [ + "arc-swap", + "libc", +] + [[package]] name = "slab" version = "0.4.2" @@ -2102,13 +2141,25 @@ version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c2fb2ec9bcd216a5b0d0ccf31ab17b5ed1d627960edff65bbe95d3ce221cefc" +[[package]] +name = "socket2" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8b74de517221a2cb01a53349cf54182acdc31a074727d3079068448c0676d85" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall", + "winapi 0.3.8", +] + [[package]] name = "string" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d24114bfcceb867ca7f71a0d3fe45d45619ec47a6fbfa98cb14e14250bfa5d6d" dependencies = [ - "bytes", + "bytes 0.4.12", ] [[package]] @@ -2136,12 +2187,12 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.14" +version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af6f3550d8dff9ef7dc34d384ac6f107e5d31c8f57d9f28e0081503f547ac8f5" +checksum = "0df0eb663f387145cab623dea85b09c2c5b4b0aef44e945d928e682fce71bb03" dependencies = [ - "proc-macro2 1.0.8", - "quote 1.0.2", + "proc-macro2 1.0.9", + "quote 1.0.3", "unicode-xid 0.2.0", ] @@ -2151,9 +2202,9 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "67656ea1dc1b41b1451851562ea232ec2e5a80242139f7e679ceccfb5d61f545" dependencies = [ - "proc-macro2 1.0.8", - "quote 1.0.2", - "syn 1.0.14", + "proc-macro2 1.0.9", + "quote 1.0.3", + "syn 1.0.17", "unicode-xid 0.2.0", ] @@ -2283,44 +2334,52 @@ version = "0.1.22" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5a09c0b5bb588872ab2f09afa13ee6e9dac11e10a0ec9e8e3ba39a5a5d530af6" dependencies = [ - "bytes", + "bytes 0.4.12", "futures 0.1.29", "mio", "num_cpus", - "tokio-codec", "tokio-current-thread", "tokio-executor", - "tokio-fs", "tokio-io", "tokio-reactor", - "tokio-sync", "tokio-tcp", "tokio-threadpool", "tokio-timer", - "tokio-udp", - "tokio-uds", ] [[package]] -name = "tokio-buf" -version = "0.1.1" +name = "tokio" +version = "0.2.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8fb220f46c53859a4b7ec083e41dec9778ff0b1851c0942b211edb89e0ccdc46" +checksum = "0fa5e81d6bc4e67fe889d5783bd2a128ab2e0cfa487e0be16b6a8d177b101616" dependencies = [ - "bytes", - "either", - "futures 0.1.29", + "bytes 0.5.4", + "fnv", + "futures-core", + "iovec", + "lazy_static 1.4.0", + "libc", + "memchr 2.3.3", + "mio", + "mio-named-pipes", + "mio-uds", + "num_cpus", + "pin-project-lite", + "signal-hook-registry", + "slab", + "tokio-macros", + "winapi 0.3.8", ] [[package]] -name = "tokio-codec" -version = "0.1.2" +name = "tokio-buf" +version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25b2998660ba0e70d18684de5d06b70b70a3a747469af9dea7618cc59e75976b" +checksum = "8fb220f46c53859a4b7ec083e41dec9778ff0b1851c0942b211edb89e0ccdc46" dependencies = [ - "bytes", + "bytes 0.4.12", + "either", "futures 0.1.29", - "tokio-io", ] [[package]] @@ -2344,25 +2403,25 @@ dependencies = [ ] [[package]] -name = "tokio-fs" -version = "0.1.7" +name = "tokio-io" +version = "0.1.13" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "297a1206e0ca6302a0eed35b700d292b275256f596e2f3fea7729d5e629b6ff4" +checksum = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674" dependencies = [ + "bytes 0.4.12", "futures 0.1.29", - "tokio-io", - "tokio-threadpool", + "log 0.4.8", ] [[package]] -name = "tokio-io" -version = "0.1.13" +name = "tokio-macros" +version = "0.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57fc868aae093479e3131e3d165c93b1c7474109d13c90ec0dda2a1bbfff0674" +checksum = "f0c3acc6aa564495a0f2e1d59fab677cd7f81a19994cfc7f3ad0e64301560389" dependencies = [ - "bytes", - "futures 0.1.29", - "log 0.4.8", + "proc-macro2 1.0.9", + "quote 1.0.3", + "syn 1.0.17", ] [[package]] @@ -2400,7 +2459,7 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "98df18ed66e3b72e742f185882a9e201892407957e45fbff8da17ae7a7c51f72" dependencies = [ - "bytes", + "bytes 0.4.12", "futures 0.1.29", "iovec", "mio", @@ -2437,39 +2496,6 @@ dependencies = [ "tokio-executor", ] -[[package]] -name = "tokio-udp" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2a0b10e610b39c38b031a2fcab08e4b82f16ece36504988dcbd81dbba650d82" -dependencies = [ - "bytes", - "futures 0.1.29", - "log 0.4.8", - "mio", - "tokio-codec", - "tokio-io", - "tokio-reactor", -] - -[[package]] -name = "tokio-uds" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5076db410d6fdc6523df7595447629099a1fdc47b3d9f896220780fa48faf798" -dependencies = [ - "bytes", - "futures 0.1.29", - "iovec", - "libc", - "log 0.4.8", - "mio", - "mio-uds", - "tokio-codec", - "tokio-io", - "tokio-reactor", -] - [[package]] name = "toml" version = "0.4.10" @@ -2506,7 +2532,7 @@ version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6" dependencies = [ - "version_check 0.9.1", + "version_check", ] [[package]] @@ -2609,12 +2635,6 @@ version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a" -[[package]] -name = "version_check" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd" - [[package]] name = "version_check" version = "0.9.1" diff --git a/enclave-runner/Cargo.toml b/enclave-runner/Cargo.toml index 90b9b0a9..4d8488f9 100644 --- a/enclave-runner/Cargo.toml +++ b/enclave-runner/Cargo.toml @@ -32,9 +32,8 @@ nix = "0.13.0" # MIT openssl = { version = "0.10", optional = true } # Apache-2.0 crossbeam = "0.7.1" # MIT/Apache-2.0 num_cpus = "1.10.0" # MIT/Apache-2.0 -tokio = "0.1.22" # MIT -futures = { version = "0.3.4", features = ["compat", "io-compat"] } -tokio-io = "0.1.12" +tokio = { version = "0.2", features = ["full"] } # MIT +futures = { version = "0.3", features = ["compat", "io-compat"] } [features] default = ["crypto-openssl"] diff --git a/enclave-runner/src/lib.rs b/enclave-runner/src/lib.rs index 02a317b8..664e7995 100644 --- a/enclave-runner/src/lib.rs +++ b/enclave-runner/src/lib.rs @@ -16,7 +16,6 @@ extern crate openssl; extern crate sgx_isa; extern crate sgxs; extern crate tokio; -extern crate tokio_io; #[macro_use] extern crate failure; #[macro_use] diff --git a/enclave-runner/src/library.rs b/enclave-runner/src/library.rs index f80ff943..026d7fc7 100644 --- a/enclave-runner/src/library.rs +++ b/enclave-runner/src/library.rs @@ -17,6 +17,7 @@ use std::fmt; use std::os::raw::c_void; pub struct Library { + rt: tokio::runtime::Runtime, enclave: Arc, address: *mut c_void, size: usize, @@ -49,8 +50,10 @@ impl Library { usercall_ext: Option>, forward_panics: bool, ) -> Library { + let (rt, enclave) = EnclaveState::library(tcss, usercall_ext, forward_panics); Library { - enclave: EnclaveState::library(tcss, usercall_ext, forward_panics), + rt, + enclave, address, size, } @@ -68,13 +71,13 @@ impl Library { /// The caller must ensure that the parameters passed-in match what the /// enclave is expecting. pub unsafe fn call( - &self, + &mut self, p1: u64, p2: u64, p3: u64, p4: u64, p5: u64, ) -> Result<(u64, u64), Error> { - EnclaveState::library_entry(&self.enclave, p1, p2, p3, p4, p5) + EnclaveState::library_entry(&mut self.rt, &self.enclave, p1, p2, p3, p4, p5) } } diff --git a/enclave-runner/src/usercalls/mod.rs b/enclave-runner/src/usercalls/mod.rs index eb7edcc7..aa7bd0cc 100644 --- a/enclave-runner/src/usercalls/mod.rs +++ b/enclave-runner/src/usercalls/mod.rs @@ -12,32 +12,33 @@ extern crate nix; use std::alloc::{GlobalAlloc, Layout, System}; use std::cell::RefCell; use std::collections::VecDeque; -use std::io::{self, ErrorKind as IoErrorKind, Read, Result as IoResult, Write}; +use std::io::{self, ErrorKind as IoErrorKind, Read, Result as IoResult}; use std::net::ToSocketAddrs; use std::result::Result as StdResult; use std::str; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::{cmp, fmt}; +use std::pin::Pin; use std::sync::Arc; use std::thread; use std::time; +use std::task::{Poll, Context, Waker}; use failure; use fnv::FnvHashMap; -use tokio::prelude::Stream as tokioStream; -use crate::futures::compat::Future01CompatExt; use crate::futures::StreamExt; -use futures::future::{Either, FutureExt, TryFutureExt, Future}; -use tokio::prelude::{Async, AsyncRead, AsyncWrite, Poll}; -use tokio::sync::lock::Lock; +use futures::future::{Either, FutureExt, Future, poll_fn}; +use tokio::prelude::{AsyncRead, AsyncWrite}; +use tokio::sync::Mutex; use tokio::sync::mpsc as async_mpsc; +use tokio::stream::Stream as TokioStream; use fortanix_sgx_abi::*; use sgxs::loader::Tcs as SgxsTcs; lazy_static! { - static ref DEBUGGER_TOGGLE_SYNC: Lock<()> = Lock::new(()); + static ref DEBUGGER_TOGGLE_SYNC: Mutex<()> = Mutex::new(()); } pub(crate) mod abi; @@ -58,86 +59,62 @@ const EV_ABORT: u64 = 0b0000_0000_0000_1000; type UsercallSendData = (ThreadResult, RunningTcs, RefCell<[u8; 1024]>); -struct ReadOnly(R); -struct WriteOnly(W); - -macro_rules! poll_lock_await_unwrap { - ($lock:expr) => { - tokio::prelude::future::poll_fn( || - match $lock.clone().poll_lock() { - Async::NotReady => IoResult::Ok(Async::NotReady), - Async::Ready(ret) => IoResult::Ok(Async::Ready(ret)), - }).compat().await.unwrap() - } -} +struct ReadOnly(Pin>); +struct WriteOnly(Pin>); macro_rules! forward { - (fn $n:ident(&mut self $(, $p:ident : $t:ty)*) -> $ret:ty) => { - fn $n(&mut self $(, $p: $t)*) -> $ret { - self.0 .$n($($p),*) + (fn $n:ident(mut self: Pin<&mut Self> $(, $p:ident : $t:ty)*) -> $ret:ty) => { + fn $n(mut self: Pin<&mut Self> $(, $p: $t)*) -> $ret { + self.0.as_mut().$n($($p),*) } } } -impl Read for ReadOnly { - forward!(fn read(&mut self, buf: &mut [u8]) -> IoResult); +impl AsyncRead for ReadOnly { + forward!(fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll>); } -impl Read for WriteOnly { - fn read(&mut self, _buf: &mut [u8]) -> IoResult { - Err(IoErrorKind::BrokenPipe.into()) +impl AsyncRead for WriteOnly { + fn poll_read(self: Pin<&mut Self>, _cx: &mut Context, _buf: &mut [u8]) -> Poll> { + Poll::Ready(Err(IoErrorKind::BrokenPipe.into())) } } -impl Write for ReadOnly { - fn write(&mut self, _buf: &[u8]) -> IoResult { - Err(IoErrorKind::BrokenPipe.into()) +impl AsyncWrite for ReadOnly { + fn poll_write(self: Pin<&mut Self>, _cx: &mut Context, _buf: &[u8]) -> Poll> { + Poll::Ready(Err(IoErrorKind::BrokenPipe.into())) } - fn flush(&mut self) -> IoResult<()> { - Err(IoErrorKind::BrokenPipe.into()) + fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll> { + Poll::Ready(Err(IoErrorKind::BrokenPipe.into())) } -} -impl Write for WriteOnly { - forward!(fn write(&mut self, buf: &[u8]) -> IoResult); - forward!(fn flush(&mut self) -> IoResult<()>); -} - -impl AsyncWrite for ReadOnly { - fn shutdown(&mut self) -> Poll<(), std::io::Error> { - return Err(IoErrorKind::BrokenPipe.into()); + fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context) -> Poll> { + Poll::Ready(Err(IoErrorKind::BrokenPipe.into())) } } -impl AsyncRead for ReadOnly where T: std::io::Read {} - -impl AsyncRead for WriteOnly {} - -impl AsyncWrite for WriteOnly -where - T: std::io::Write, -{ - fn shutdown(&mut self) -> Poll<(), std::io::Error> { - self.0.flush().map(|k| k.into()) - } +impl AsyncWrite for WriteOnly { + forward!(fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll>); + forward!(fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll>); + forward!(fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll>); } struct Stdin; -impl Read for Stdin { - fn read(&mut self, buf: &mut [u8]) -> io::Result { +impl AsyncRead for Stdin { + fn poll_read(self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll> { const BUF_SIZE: usize = 8192; trait AsIoResult { fn as_io_result(self) -> io::Result; } - impl AsIoResult for Async { + impl AsIoResult for Poll { fn as_io_result(self) -> io::Result { match self { - Async::Ready(v) => Ok(v), - Async::NotReady => Err(io::ErrorKind::WouldBlock.into()), + Poll::Ready(v) => Ok(v), + Poll::Pending => Err(io::ErrorKind::WouldBlock.into()), } } } @@ -148,7 +125,7 @@ impl Read for Stdin { } lazy_static::lazy_static! { - static ref STDIN: Lock = { + static ref STDIN: futures::lock::Mutex = { let (mut tx, rx) = async_mpsc::channel(8); thread::spawn(move || { let mut buf = [0u8; BUF_SIZE]; @@ -162,43 +139,40 @@ impl Read for Stdin { }; } }); - Lock::new(AsyncStdin { rx, buf: VecDeque::new() }) + futures::lock::Mutex::new(AsyncStdin { rx, buf: VecDeque::new() }) }; } - let mut stdin = STDIN.clone().poll_lock().as_io_result()?; - if stdin.buf.is_empty() { - let pipeerr = || -> io::Error { io::ErrorKind::BrokenPipe.into() }; - stdin.buf = stdin - .rx - .poll() - .map_err(|_| pipeerr())? - .as_io_result()? - .ok_or_else(pipeerr)?; + match Pin::new(&mut STDIN.lock()).poll(cx) { + Poll::Ready(mut stdin) => { + if stdin.buf.is_empty() { + let pipeerr = tokio::io::Error::new(tokio::io::ErrorKind::BrokenPipe, "broken pipe"); + stdin.buf = match Pin::new(&mut stdin.rx).poll_next(cx) { + Poll::Ready(Some(vec)) => vec, + Poll::Ready(None) => return Poll::Ready(Err(pipeerr)), + _ => return Poll::Pending, + }; + } + let inbuf = match stdin.buf.as_slices() { + (&[], inbuf) => inbuf, + (inbuf, _) => inbuf, + }; + let len = cmp::min(buf.len(), inbuf.len()); + buf[..len].copy_from_slice(&inbuf[..len]); + stdin.buf.drain(..len); + Poll::Ready(Ok(len)) + } + Poll::Pending => Poll::Pending } - let inbuf = match stdin.buf.as_slices() { - (&[], inbuf) => inbuf, - (inbuf, _) => inbuf, - }; - let len = cmp::min(buf.len(), inbuf.len()); - buf[..len].copy_from_slice(&inbuf[..len]); - stdin.buf.drain(..len); - Ok(len) } } pub trait AsyncStream: AsyncRead + AsyncWrite + 'static + Send + Sync { - fn poll_read_alloc(&mut self) -> tokio::prelude::Poll, std::io::Error> + fn poll_read_alloc(self: Pin<&mut Self>, cx: &mut Context) -> Poll>> { let mut v: Vec = vec![0; 8192]; - self.poll_read(v.as_mut_slice()).map(move |size| { - match size { - Async::NotReady => Async::NotReady, - Async::Ready(size) => { - v.truncate(size); - Async::Ready(v) - } - } + self.poll_read(cx, v.as_mut_slice()).map(move |size| { + size.map(|size| { v.resize(size, 0); v }) }) } } @@ -206,7 +180,7 @@ pub trait AsyncStream: AsyncRead + AsyncWrite + 'static + Send + Sync { impl AsyncStream for S {} /// AsyncListener lets an implementation implement a slightly modified form of `std::net::TcpListener::accept`. -pub trait AsyncListener: 'static + Send { +pub trait AsyncListener: Send { /// The enclave may optionally request the local or peer addresses /// be returned in `local_addr` or `peer_addr`, respectively. /// If `local_addr` and/or `peer_addr` are not `None`, they will point to an empty `String`. @@ -214,184 +188,194 @@ pub trait AsyncListener: 'static + Send { /// /// The enclave must not make any security decisions based on the local address received. fn poll_accept( - &mut self, + self: Pin<&mut Self>, + cx: &mut Context, local_addr: Option<&mut String>, peer_addr: Option<&mut String>, - ) -> tokio::io::Result>>>; + ) -> Poll>>>; } struct AsyncStreamAdapter { - stream: Box, - read_queue: VecDeque, - write_queue: VecDeque, - flush_queue: VecDeque, + stream: Pin>, + read_queue: VecDeque, + write_queue: VecDeque, + flush_queue: VecDeque, } -fn notify_other_tasks(queue: &mut VecDeque) { +fn notify_other_tasks(cx: &mut Context, queue: &mut VecDeque) { for task in queue.drain(..) { - if !task.will_notify_current() { - task.notify(); + if !task.will_wake(&cx.waker()) { + task.wake(); } } } impl AsyncStreamAdapter { - - fn poll_read_alloc(&mut self) -> tokio::io::Result>> { - match self.stream.poll_read_alloc() { - Ok(Async::NotReady) => { - self.read_queue.push_back(tokio::prelude::task::current()); - Ok(Async::NotReady) + fn poll_read_alloc(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll>> { + match self.stream.as_mut().poll_read_alloc(cx) { + Poll::Pending => { + self.read_queue.push_back(cx.waker().clone()); + Poll::Pending } - Ok(Async::Ready(ret)) => { - notify_other_tasks(&mut self.read_queue); - Ok(Async::Ready(ret)) + Poll::Ready(Ok(ret)) => { + notify_other_tasks(cx, &mut self.read_queue); + Poll::Ready(Ok(ret)) } - Err(e) => Err(e), + Poll::Ready(Err(e)) => Poll::Ready(Err(e)), } } - fn poll_read(&mut self, buf: &mut [u8]) -> tokio::io::Result> { - match self.stream.poll_read(buf) { - Ok(Async::NotReady) => { - self.read_queue.push_back(tokio::prelude::task::current()); - Ok(Async::NotReady) + fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context, buf: &mut [u8]) -> Poll> { + match self.stream.as_mut().poll_read(cx, buf) { + Poll::Pending => { + self.read_queue.push_back(cx.waker().clone()); + Poll::Pending } - Ok(Async::Ready(ret)) => { - notify_other_tasks(&mut self.read_queue); - Ok(Async::Ready(ret)) + Poll::Ready(Ok(ret)) => { + notify_other_tasks(cx, &mut self.read_queue); + Poll::Ready(Ok(ret)) } - Err(e) => Err(e), + Poll::Ready(Err(e)) => Poll::Ready(Err(e)), } } - fn poll_write(&mut self, buf: &[u8]) -> tokio::io::Result> { - match self.stream.poll_write(buf) { - Ok(Async::NotReady) => { - self.write_queue.push_back(tokio::prelude::task::current()); - Ok(Async::NotReady) + fn poll_write(mut self: Pin<&mut Self>, cx: &mut Context, buf: &[u8]) -> Poll> { + match self.stream.as_mut().poll_write(cx, buf) { + Poll::Pending => { + self.write_queue.push_back(cx.waker().clone()); + Poll::Pending } - Ok(Async::Ready(ret)) => { - notify_other_tasks(&mut self.write_queue); - Ok(Async::Ready(ret)) + Poll::Ready(Ok(ret)) => { + notify_other_tasks(cx, &mut self.write_queue); + Poll::Ready(Ok(ret)) } - Err(e) => Err(e), + Poll::Ready(Err(e)) => Poll::Ready(Err(e)), } } - fn poll_flush(&mut self) -> tokio::io::Result> { - match self.stream.poll_flush() { - Ok(Async::NotReady) => { - self.flush_queue.push_back(tokio::prelude::task::current()); - Ok(Async::NotReady) + fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll> { + match self.stream.as_mut().poll_flush(cx) { + Poll::Pending => { + self.flush_queue.push_back(cx.waker().clone()); + Poll::Pending } - Ok(Async::Ready(ret)) => { - notify_other_tasks(&mut self.flush_queue); - Ok(Async::Ready(ret)) + Poll::Ready(Ok(ret)) => { + notify_other_tasks(cx, &mut self.flush_queue); + Poll::Ready(Ok(ret)) } - Err(e) => Err(e), + Poll::Ready(Err(e)) => Poll::Ready(Err(e)), } } } struct AsyncStreamContainer { - inner: Lock, + inner: futures::lock::Mutex>>, } impl AsyncStreamContainer { fn new(s: Box) -> Self { AsyncStreamContainer { - inner: Lock::new(AsyncStreamAdapter { - stream: s, + inner: futures::lock::Mutex::new(Box::pin(AsyncStreamAdapter { + stream: s.into(), read_queue: VecDeque::new(), write_queue: VecDeque::new(), flush_queue: VecDeque::new(), - }), + })), } } async fn async_read(&self, buf: &mut [u8]) -> IoResult { - tokio::prelude::future::poll_fn(|| match self.inner.clone().poll_lock() { - Async::NotReady => Ok(Async::NotReady), - Async::Ready(mut adapter) => adapter.poll_read(buf), - }) - .compat() - .await + poll_fn(|cx| { + let inner_ref = &mut self.inner.lock(); + let mut inner = Pin::new(inner_ref); + match inner.as_mut().poll(cx) { + Poll::Ready(mut adapter) => adapter.as_mut().poll_read(cx, buf), + Poll::Pending => Poll::Pending, + } + }).await } async fn async_read_alloc(&self) -> IoResult> { - tokio::prelude::future::poll_fn(|| match self.inner.clone().poll_lock() { - Async::NotReady => Ok(Async::NotReady), - Async::Ready(mut adapter) => adapter.poll_read_alloc(), - }) - .compat() - .await + poll_fn(|cx| { + let inner_ref = &mut self.inner.lock(); + let mut inner = Pin::new(inner_ref); + match inner.as_mut().poll(cx) { + Poll::Ready(mut adapter) => adapter.as_mut().poll_read_alloc(cx), + Poll::Pending => Poll::Pending, + } + }).await } - async fn async_write(&self, buf: Vec) -> IoResult { - tokio::prelude::future::poll_fn(|| match self.inner.clone().poll_lock() { - Async::NotReady => Ok(Async::NotReady), - Async::Ready(mut adapter) => adapter.poll_write(buf.as_slice()), - }) - .compat() - .await + async fn async_write(&self, buf: &[u8]) -> IoResult { + poll_fn(|cx| { + let inner_ref = &mut self.inner.lock(); + let mut inner = Pin::new(inner_ref); + match inner.as_mut().poll(cx) { + Poll::Ready(mut adapter) => adapter.as_mut().poll_write(cx, buf), + Poll::Pending => Poll::Pending, + } + }).await } async fn async_flush(&self) -> IoResult<()> { - tokio::prelude::future::poll_fn(|| match self.inner.clone().poll_lock() { - Async::NotReady => Ok(Async::NotReady), - Async::Ready(mut adapter) => adapter.poll_flush(), - }) - .compat() - .await + poll_fn(|cx| { + let inner_ref = &mut self.inner.lock(); + let mut inner = Pin::new(inner_ref); + match inner.as_mut().poll(cx) { + Poll::Ready(mut adapter) => adapter.as_mut().poll_flush(cx), + Poll::Pending => Poll::Pending, + } + }).await } } struct AsyncListenerAdapter { - listener: Box, - accept_queue: VecDeque, + listener: Pin>, + accept_queue: VecDeque, } impl AsyncListenerAdapter { - fn poll_accept(&mut self, local_addr: Option<&mut String>, peer_addr: Option<&mut String>) -> tokio::io::Result>>> { - match self.listener.poll_accept(local_addr, peer_addr) { - Ok(Async::NotReady) => { - self.accept_queue.push_back(tokio::prelude::task::current()); - Ok(Async::NotReady) + fn poll_accept( + mut self: Pin<&mut Self>, + cx: &mut Context, + local_addr: Option<&mut String>, + peer_addr: Option<&mut String> + ) -> Poll>>> { + match self.listener.as_mut().poll_accept(cx, local_addr, peer_addr) { + Poll::Pending => { + self.accept_queue.push_back(cx.waker().clone()); + Poll::Pending } - Ok(Async::Ready(ret)) => { - notify_other_tasks(&mut self.accept_queue); - Ok(Async::Ready(ret)) + Poll::Ready(Ok(ret)) => { + notify_other_tasks(cx, &mut self.accept_queue); + Poll::Ready(Ok(ret)) } - Err(e) => Err(e), + Poll::Ready(Err(e)) => Poll::Ready(Err(e)), } } } struct AsyncListenerContainer { - inner: Lock, + inner: futures::lock::Mutex>>, } impl AsyncListenerContainer { fn new(l: Box) -> Self { AsyncListenerContainer { - inner: Lock::new(AsyncListenerAdapter { - listener: l, + inner: futures::lock::Mutex::new(Pin::new(Box::new(AsyncListenerAdapter { + listener: l.into(), accept_queue: VecDeque::new(), - }), + }))), } } async fn async_accept(&self, local_addr: Option<&mut String>, peer_addr: Option<&mut String>) -> IoResult>> { let mut local_addr_owned: Option = if local_addr.is_some() { Some(String::new()) } else { None }; let mut peer_addr_owned: Option = if peer_addr.is_some() { Some(String::new()) } else { None }; - - let res = tokio::prelude::future::poll_fn(|| match self.inner.clone().poll_lock() { - Async::NotReady => Ok(Async::NotReady), - Async::Ready(mut inner) => inner.poll_accept(local_addr_owned.as_mut(), peer_addr_owned.as_mut()), - }) - .compat() - .await; + let lock = &mut self.inner.lock().await; + let res = poll_fn(|cx| { + lock.as_mut().poll_accept(cx, local_addr_owned.as_mut(), peer_addr_owned.as_mut()) + }).await; if let Some(local_addr) = local_addr { *local_addr = local_addr_owned.unwrap(); @@ -403,25 +387,28 @@ impl AsyncListenerContainer { } } -impl AsyncListener for tokio::net::tcp::Incoming { +impl AsyncListener for tokio::net::TcpListener { fn poll_accept( - &mut self, + mut self: Pin<&mut Self>, + cx: &mut Context, local_addr: Option<&mut String>, peer_addr: Option<&mut String>, - ) -> tokio::io::Result>>> { - match self.poll() { - Ok(Async::Ready(Some(stream))) => { + ) -> Poll>>> { + let mut incoming = self.incoming(); + let inner = Pin::new(&mut incoming); + match inner.poll_next(cx) { + Poll::Ready(Some(Ok(stream))) => { if let Some(local_addr) = local_addr { *local_addr = stream.local_addr().map(|addr| addr.to_string()).unwrap_or_else(|_err| "error".to_owned()); } if let Some(peer_addr) = peer_addr { *peer_addr = stream.peer_addr().map(|addr| addr.to_string()).unwrap_or_else(|_err| "error".to_owned()); } - Ok(Async::Ready(Some(Box::new(stream)))) + Poll::Ready(Ok(Some(Box::new(stream)))) } - Ok(Async::Ready(None)) => Ok(Async::Ready(None)), - Ok(Async::NotReady) => Ok(Async::NotReady), - Err(e) => Err(e), + Poll::Ready(Some(Err(e))) => Poll::Ready(Err(e)), + Poll::Ready(None) => Poll::Ready(Ok(None)), + Poll::Pending => Poll::Pending, } } } @@ -513,7 +500,7 @@ struct PanicReason { } struct Command { - panic_reason: Lock, + panic_reason: Mutex, } struct Library {} @@ -537,7 +524,7 @@ impl EnclaveKind { pub(crate) struct EnclaveState { kind: EnclaveKind, event_queues: FnvHashMap>, - fds: Lock>>, + fds: Mutex>>, last_fd: AtomicUsize, exiting: AtomicBool, usercall_ext: Box, @@ -569,7 +556,7 @@ impl Work { } }; // if there is an error do nothing, as it means that the main thread has exited - let _ = io_send_queue.try_send(usercall_send_data); + let _ = io_send_queue.send(usercall_send_data); } } @@ -594,25 +581,25 @@ impl EnclaveState { usercall_ext: Option>, threads_vector: Vec, forward_panics: bool, - ) -> Arc { + ) -> (tokio::runtime::Runtime, Arc) { let mut fds = FnvHashMap::default(); fds.insert( FD_STDIN, Arc::new(AsyncFileDesc::stream(Box::new(ReadOnly( - Stdin, + Box::pin(Stdin) )))), ); fds.insert( FD_STDOUT, Arc::new(AsyncFileDesc::stream(Box::new(WriteOnly( - tokio_io::io::AllowStdIo::new(io::stdout()), + Box::pin(tokio::io::stdout()), )))), ); fds.insert( FD_STDERR, Arc::new(AsyncFileDesc::stream(Box::new(WriteOnly( - tokio_io::io::AllowStdIo::new(io::stderr()), + Box::pin(tokio::io::stderr()), )))), ); let last_fd = AtomicUsize::new(fds.keys().cloned().max().unwrap() as _); @@ -625,27 +612,31 @@ impl EnclaveState { threads_queue.push(Self::event_queue_add_tcs(&mut event_queues, thread)); } - Arc::new(EnclaveState { + let rt = tokio::runtime::Runtime::new().unwrap(); + (rt, Arc::new(EnclaveState { kind, event_queues, - fds: Lock::new(fds), + fds: Mutex::new(fds), last_fd, exiting: AtomicBool::new(false), usercall_ext, threads_queue, forward_panics, - }) + })) } fn syscall_loop( + rt: &mut tokio::runtime::Runtime, enclave: Arc, io_queue_receive: tokio::sync::mpsc::UnboundedReceiver, work_sender: crossbeam::crossbeam_channel::Sender, ) -> StdResult<(u64, u64), EnclaveAbort> { let (tx_return_channel, mut rx_return_channel) = tokio::sync::mpsc::unbounded_channel(); let enclave_clone = enclave.clone(); + let local_set = tokio::task::LocalSet::new(); + let return_future = async move { - while let Ok((Some(work), stream)) = rx_return_channel.into_future().compat().await { + while let (Some(work), stream) = rx_return_channel.into_future().await { rx_return_channel = stream; let (my_result, mode) = work; let res = match (my_result, mode) { @@ -661,7 +652,7 @@ impl EnclaveState { EnclaveEntry::ExecutableNonMain, ) => { let cmd = enclave_clone.kind.as_command().unwrap(); - let mut cmddata = poll_lock_await_unwrap!(cmd.panic_reason); + let mut cmddata = cmd.panic_reason.lock().await; if cmddata.primary_panic_reason.is_none() { cmddata.primary_panic_reason = Some(e) @@ -672,7 +663,7 @@ impl EnclaveState { } (Err(e), EnclaveEntry::ExecutableNonMain) => { let cmd = enclave_clone.kind.as_command().unwrap(); - let mut cmddata = poll_lock_await_unwrap!(cmd.panic_reason); + let mut cmddata = cmd.panic_reason.lock().await; cmddata.other_reasons.push(e); continue; } @@ -684,9 +675,9 @@ impl EnclaveState { let enclave_clone = enclave.clone(); let io_future = async move { let mut recv_queue = io_queue_receive.into_future(); - while let Ok((Some(work), stream)) = recv_queue.compat().await { - let work_sender = work_sender.clone(); - let mut tx_return_channel = tx_return_channel.clone(); + while let (Some(work), stream) = recv_queue.await { + let work_sender_clone = work_sender.clone(); + let tx_clone = tx_return_channel.clone(); let enclave_clone = enclave_clone.clone(); recv_queue = stream.into_future(); let (coresult, mut state, buf) = work; @@ -696,7 +687,7 @@ impl EnclaveState { let mut input = IOHandlerInput { enclave: enclave_clone.clone(), tcs: &mut state, - work_sender: &work_sender, + work_sender: &work_sender_clone, }; let handler = Handler(&mut input); let (_handler, result) = { @@ -705,7 +696,7 @@ impl EnclaveState { }; let ret = match result { Ok(ret) => { - work_sender + work_sender_clone .send(Work { tcs: state, entry: CoEntry::Resume(usercall, ret), @@ -734,12 +725,9 @@ impl EnclaveState { Err(EnclaveAbort::MainReturned) => Err(EnclaveAbort::MainReturned), Err(EnclaveAbort::Secondary) => Err(EnclaveAbort::Secondary), }; - let _ = tx_return_channel.try_send((ret, state.mode)); - } - .unit_error() - .boxed_local() - .compat(); - tokio::runtime::current_thread::spawn(fut); + let _ = tx_clone.send((ret, state.mode)); + }; + tokio::task::spawn_local(fut); } CoResult::Return((tcs, v1, v2)) => { let fut = async move { @@ -769,12 +757,9 @@ impl EnclaveState { Ok((0, 0)) } }; - let _ = tx_return_channel.try_send((ret, state.mode)); - } - .unit_error() - .boxed_local() - .compat(); - tokio::runtime::current_thread::spawn(fut); + let _ = tx_clone.send((ret, state.mode)); + }; + tokio::task::spawn_local(fut); } }; } @@ -793,11 +778,11 @@ impl EnclaveState { } }); - let mut rt = tokio::runtime::current_thread::Runtime::new().expect("failed to create tokio runtime"); - rt.block_on(select_fut.unit_error().compat()).unwrap() + local_set.block_on(rt, select_fut.unit_error()).unwrap() } fn run( + rt: &mut tokio::runtime::Runtime, enclave: Arc, num_of_worker_threads: usize, start_work: Work, @@ -832,7 +817,7 @@ impl EnclaveState { create_worker_threads(num_of_worker_threads, work_receiver, io_queue_send); // main syscall polling loop let main_result = - EnclaveState::syscall_loop(enclave.clone(), io_queue_receive, work_sender); + EnclaveState::syscall_loop(rt, enclave.clone(), io_queue_receive, work_sender); for handler in join_handlers { let _ = handler.join(); @@ -863,14 +848,14 @@ impl EnclaveState { let num_of_worker_threads = num_cpus::get(); let kind = EnclaveKind::Command(Command { - panic_reason: Lock::new(PanicReason { + panic_reason: Mutex::new(PanicReason { primary_panic_reason: None, other_reasons: vec![], }), }); - let enclave = EnclaveState::new(kind, event_queues, usercall_ext, threads, forward_panics); + let (mut rt, enclave) = EnclaveState::new(kind, event_queues, usercall_ext, threads, forward_panics); - let main_result = EnclaveState::run(enclave.clone(), num_of_worker_threads, main_work); + let main_result = EnclaveState::run(&mut rt, enclave.clone(), num_of_worker_threads, main_work); let main_panicking = match main_result { Err(EnclaveAbort::MainReturned) @@ -878,14 +863,13 @@ impl EnclaveState { | Err(EnclaveAbort::Exit { .. }) => true, Err(EnclaveAbort::IndefiniteWait) | Err(EnclaveAbort::Secondary) | Ok(_) => false, }; - - tokio::runtime::current_thread::block_on_all(async move { + rt.block_on(async move { enclave.abort_all_threads(); //clear the threads_queue while enclave.threads_queue.pop().is_ok() {} let cmd = enclave.kind.as_command().unwrap(); - let mut cmddata = poll_lock_await_unwrap!(cmd.panic_reason);//.lock().await; + let mut cmddata = cmd.panic_reason.lock().await; let main_result = match (main_panicking, cmddata.primary_panic_reason.take()) { (false, Some(reason)) => Err(reason), // TODO: interpret other_reasons @@ -906,14 +890,14 @@ impl EnclaveState { Err(EnclaveAbort::Secondary) => unreachable!(), Ok(_) => Ok(()), } - }.boxed_local().compat()) + }.boxed_local()) } pub(crate) fn library( threads: Vec, usercall_ext: Option>, forward_panics: bool, - ) -> Arc { + ) -> (tokio::runtime::Runtime, Arc) { let event_queues = FnvHashMap::with_capacity_and_hasher(threads.len(), Default::default()); let kind = EnclaveKind::Library(Library {}); @@ -923,6 +907,7 @@ impl EnclaveState { } pub(crate) fn library_entry( + rt: &mut tokio::runtime::Runtime, enclave: &Arc, p1: u64, p2: u64, @@ -944,7 +929,7 @@ impl EnclaveState { // one for usercall handling the other for actually running let num_of_worker_threads = 1; - let library_result = EnclaveState::run(enclave.clone(), num_of_worker_threads, work); + let library_result = EnclaveState::run(rt, enclave.clone(), num_of_worker_threads, work); match library_result { Err(EnclaveAbort::Exit { panic }) => Err(panic.into()), @@ -1029,7 +1014,7 @@ extern "C" fn handle_trap(_signo: c_int, _info: *mut siginfo_t, context: *mut c_ * set sgx state and correctly map the enclave symbols. */ async fn trap_attached_debugger(tcs: usize) { - let _g = poll_lock_await_unwrap!(DEBUGGER_TOGGLE_SYNC); + let _g = DEBUGGER_TOGGLE_SYNC.lock().await; let hdl = self::signal::SigHandler::SigAction(handle_trap); let sig_action = signal::SigAction::new(hdl, signal::SaFlags::empty(), signal::SigSet::empty()); // Synchronized @@ -1098,7 +1083,7 @@ impl UsercallExtension for UsercallExtensionDefault {} impl<'tcs> IOHandlerInput<'tcs> { async fn lookup_fd(&self, fd: Fd) -> IoResult> { - match poll_lock_await_unwrap!(self.enclave.fds).get(&fd) { + match self.enclave.fds.lock().await.get(&fd) { Some(stream) => Ok(stream.clone()), None => Err(IoErrorKind::BrokenPipe.into()), // FIXME: Rust normally maps Unix EBADF to `Other` } @@ -1111,7 +1096,7 @@ impl<'tcs> IOHandlerInput<'tcs> { .fetch_add(1, Ordering::Relaxed) .checked_add(1) .expect("FD overflow")) as Fd; - let prev = poll_lock_await_unwrap!(self.enclave.fds).insert(fd, Arc::new(stream)); + let prev = self.enclave.fds.lock().await.insert(fd, Arc::new(stream)); debug_assert!(prev.is_none()); fd } @@ -1137,9 +1122,8 @@ impl<'tcs> IOHandlerInput<'tcs> { #[inline(always)] async fn write(&self, fd: Fd, buf: &[u8]) -> IoResult { - let vec = buf.to_vec(); let file_desc = self.lookup_fd(fd).await?; - return file_desc.as_stream()?.async_write(vec).await; + return file_desc.as_stream()?.async_write(buf).await; } #[inline(always)] @@ -1150,7 +1134,7 @@ impl<'tcs> IOHandlerInput<'tcs> { #[inline(always)] async fn close(&self, fd: Fd) { - poll_lock_await_unwrap!(self.enclave.fds).remove(&fd); + self.enclave.fds.lock().await.remove(&fd); } #[inline(always)] @@ -1172,11 +1156,11 @@ impl<'tcs> IOHandlerInput<'tcs> { return Ok(self.alloc_fd(AsyncFileDesc::listener(stream_ext)).await); } - let socket = tokio::net::TcpListener::bind(&addr.to_socket_addrs()?.next().unwrap())?; + // !!! see if there's a better way + let socket = tokio::net::TcpListener::bind(&addr.to_socket_addrs()?.as_mut_slice()[0]).await?; if let Some(local_addr) = local_addr { local_addr.set(socket.local_addr()?.to_string().into_bytes()); } - let socket = socket.incoming(); Ok(self.alloc_fd(AsyncFileDesc::listener(Box::new(socket))).await) } @@ -1229,7 +1213,7 @@ impl<'tcs> IOHandlerInput<'tcs> { // try to connect to all socket addresses one by one let mut stream = None; for socket_addr in addr.to_socket_addrs()? { - stream = Some(tokio::net::TcpStream::connect(&socket_addr).compat().await); + stream = Some(tokio::net::TcpStream::connect(&socket_addr).await); if stream.as_ref().unwrap().is_ok() { break; } diff --git a/sgxs-tools/src/sgx_detect/tests/mod.rs b/sgxs-tools/src/sgx_detect/tests/mod.rs index 18356f64..d4779496 100644 --- a/sgxs-tools/src/sgx_detect/tests/mod.rs +++ b/sgxs-tools/src/sgx_detect/tests/mod.rs @@ -746,7 +746,7 @@ impl RunEnclaveProdWl { let mut builder = EnclaveBuilder::new_from_memory(enclave); builder.attributes(sig.attributes).sigstruct(sig); - let lib = builder.build_library(enclave_loader)?; + let mut lib = builder.build_library(enclave_loader)?; unsafe { match lib.call(!0, 0, 0, 0, 0) { From c63b5cbda283ac3424917cd05aba6f4e19c0687e Mon Sep 17 00:00:00 2001 From: Mohsen Zohrevandi Date: Mon, 6 Apr 2020 12:00:18 -0700 Subject: [PATCH 2/4] simplify runtime creation/use --- enclave-runner/src/library.rs | 8 +++---- enclave-runner/src/usercalls/mod.rs | 34 ++++++++++++++++++----------- 2 files changed, 24 insertions(+), 18 deletions(-) diff --git a/enclave-runner/src/library.rs b/enclave-runner/src/library.rs index 026d7fc7..5e9839b8 100644 --- a/enclave-runner/src/library.rs +++ b/enclave-runner/src/library.rs @@ -17,7 +17,6 @@ use std::fmt; use std::os::raw::c_void; pub struct Library { - rt: tokio::runtime::Runtime, enclave: Arc, address: *mut c_void, size: usize, @@ -50,9 +49,8 @@ impl Library { usercall_ext: Option>, forward_panics: bool, ) -> Library { - let (rt, enclave) = EnclaveState::library(tcss, usercall_ext, forward_panics); + let enclave = EnclaveState::library(tcss, usercall_ext, forward_panics); Library { - rt, enclave, address, size, @@ -71,13 +69,13 @@ impl Library { /// The caller must ensure that the parameters passed-in match what the /// enclave is expecting. pub unsafe fn call( - &mut self, + &self, p1: u64, p2: u64, p3: u64, p4: u64, p5: u64, ) -> Result<(u64, u64), Error> { - EnclaveState::library_entry(&mut self.rt, &self.enclave, p1, p2, p3, p4, p5) + EnclaveState::library_entry(&self.enclave, p1, p2, p3, p4, p5) } } diff --git a/enclave-runner/src/usercalls/mod.rs b/enclave-runner/src/usercalls/mod.rs index aa7bd0cc..01f149f2 100644 --- a/enclave-runner/src/usercalls/mod.rs +++ b/enclave-runner/src/usercalls/mod.rs @@ -581,7 +581,7 @@ impl EnclaveState { usercall_ext: Option>, threads_vector: Vec, forward_panics: bool, - ) -> (tokio::runtime::Runtime, Arc) { + ) -> Arc { let mut fds = FnvHashMap::default(); fds.insert( @@ -612,8 +612,7 @@ impl EnclaveState { threads_queue.push(Self::event_queue_add_tcs(&mut event_queues, thread)); } - let rt = tokio::runtime::Runtime::new().unwrap(); - (rt, Arc::new(EnclaveState { + Arc::new(EnclaveState { kind, event_queues, fds: Mutex::new(fds), @@ -622,17 +621,21 @@ impl EnclaveState { usercall_ext, threads_queue, forward_panics, - })) + }) } fn syscall_loop( - rt: &mut tokio::runtime::Runtime, enclave: Arc, io_queue_receive: tokio::sync::mpsc::UnboundedReceiver, work_sender: crossbeam::crossbeam_channel::Sender, ) -> StdResult<(u64, u64), EnclaveAbort> { let (tx_return_channel, mut rx_return_channel) = tokio::sync::mpsc::unbounded_channel(); let enclave_clone = enclave.clone(); + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .enable_all() + .build() + .expect("failed to create tokio Runtime"); let local_set = tokio::task::LocalSet::new(); let return_future = async move { @@ -778,11 +781,10 @@ impl EnclaveState { } }); - local_set.block_on(rt, select_fut.unit_error()).unwrap() + local_set.block_on(&mut rt, select_fut.unit_error()).unwrap() } fn run( - rt: &mut tokio::runtime::Runtime, enclave: Arc, num_of_worker_threads: usize, start_work: Work, @@ -817,7 +819,7 @@ impl EnclaveState { create_worker_threads(num_of_worker_threads, work_receiver, io_queue_send); // main syscall polling loop let main_result = - EnclaveState::syscall_loop(rt, enclave.clone(), io_queue_receive, work_sender); + EnclaveState::syscall_loop(enclave.clone(), io_queue_receive, work_sender); for handler in join_handlers { let _ = handler.join(); @@ -853,9 +855,9 @@ impl EnclaveState { other_reasons: vec![], }), }); - let (mut rt, enclave) = EnclaveState::new(kind, event_queues, usercall_ext, threads, forward_panics); + let enclave = EnclaveState::new(kind, event_queues, usercall_ext, threads, forward_panics); - let main_result = EnclaveState::run(&mut rt, enclave.clone(), num_of_worker_threads, main_work); + let main_result = EnclaveState::run(enclave.clone(), num_of_worker_threads, main_work); let main_panicking = match main_result { Err(EnclaveAbort::MainReturned) @@ -863,6 +865,13 @@ impl EnclaveState { | Err(EnclaveAbort::Exit { .. }) => true, Err(EnclaveAbort::IndefiniteWait) | Err(EnclaveAbort::Secondary) | Ok(_) => false, }; + + let mut rt = tokio::runtime::Builder::new() + .basic_scheduler() + .enable_all() + .build() + .expect("failed to create tokio Runtime"); + rt.block_on(async move { enclave.abort_all_threads(); //clear the threads_queue @@ -897,7 +906,7 @@ impl EnclaveState { threads: Vec, usercall_ext: Option>, forward_panics: bool, - ) -> (tokio::runtime::Runtime, Arc) { + ) -> Arc { let event_queues = FnvHashMap::with_capacity_and_hasher(threads.len(), Default::default()); let kind = EnclaveKind::Library(Library {}); @@ -907,7 +916,6 @@ impl EnclaveState { } pub(crate) fn library_entry( - rt: &mut tokio::runtime::Runtime, enclave: &Arc, p1: u64, p2: u64, @@ -929,7 +937,7 @@ impl EnclaveState { // one for usercall handling the other for actually running let num_of_worker_threads = 1; - let library_result = EnclaveState::run(rt, enclave.clone(), num_of_worker_threads, work); + let library_result = EnclaveState::run(enclave.clone(), num_of_worker_threads, work); match library_result { Err(EnclaveAbort::Exit { panic }) => Err(panic.into()), From 7aa574d50134e5f8b136d559f353679ebc559017 Mon Sep 17 00:00:00 2001 From: Mohsen Zohrevandi Date: Mon, 6 Apr 2020 12:19:38 -0700 Subject: [PATCH 3/4] fix TCP connect/bind, undo unnecessary changes --- enclave-runner/src/library.rs | 3 +- enclave-runner/src/usercalls/mod.rs | 45 +++++++++++--------------- sgxs-tools/src/sgx_detect/tests/mod.rs | 2 +- 3 files changed, 20 insertions(+), 30 deletions(-) diff --git a/enclave-runner/src/library.rs b/enclave-runner/src/library.rs index 5e9839b8..f80ff943 100644 --- a/enclave-runner/src/library.rs +++ b/enclave-runner/src/library.rs @@ -49,9 +49,8 @@ impl Library { usercall_ext: Option>, forward_panics: bool, ) -> Library { - let enclave = EnclaveState::library(tcss, usercall_ext, forward_panics); Library { - enclave, + enclave: EnclaveState::library(tcss, usercall_ext, forward_panics), address, size, } diff --git a/enclave-runner/src/usercalls/mod.rs b/enclave-runner/src/usercalls/mod.rs index 01f149f2..440e78d4 100644 --- a/enclave-runner/src/usercalls/mod.rs +++ b/enclave-runner/src/usercalls/mod.rs @@ -13,7 +13,6 @@ use std::alloc::{GlobalAlloc, Layout, System}; use std::cell::RefCell; use std::collections::VecDeque; use std::io::{self, ErrorKind as IoErrorKind, Read, Result as IoResult}; -use std::net::ToSocketAddrs; use std::result::Result as StdResult; use std::str; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; @@ -172,7 +171,7 @@ pub trait AsyncStream: AsyncRead + AsyncWrite + 'static + Send + Sync { { let mut v: Vec = vec![0; 8192]; self.poll_read(cx, v.as_mut_slice()).map(move |size| { - size.map(|size| { v.resize(size, 0); v }) + size.map(|size| { v.truncate(size); v }) }) } } @@ -180,7 +179,7 @@ pub trait AsyncStream: AsyncRead + AsyncWrite + 'static + Send + Sync { impl AsyncStream for S {} /// AsyncListener lets an implementation implement a slightly modified form of `std::net::TcpListener::accept`. -pub trait AsyncListener: Send { +pub trait AsyncListener: 'static + Send { /// The enclave may optionally request the local or peer addresses /// be returned in `local_addr` or `peer_addr`, respectively. /// If `local_addr` and/or `peer_addr` are not `None`, they will point to an empty `String`. @@ -372,9 +371,13 @@ impl AsyncListenerContainer { async fn async_accept(&self, local_addr: Option<&mut String>, peer_addr: Option<&mut String>) -> IoResult>> { let mut local_addr_owned: Option = if local_addr.is_some() { Some(String::new()) } else { None }; let mut peer_addr_owned: Option = if peer_addr.is_some() { Some(String::new()) } else { None }; - let lock = &mut self.inner.lock().await; let res = poll_fn(|cx| { - lock.as_mut().poll_accept(cx, local_addr_owned.as_mut(), peer_addr_owned.as_mut()) + let inner_ref = &mut self.inner.lock(); + let mut inner = Pin::new(inner_ref); + match inner.as_mut().poll(cx) { + Poll::Ready(mut adapter) => adapter.as_mut().poll_accept(cx, local_addr_owned.as_mut(), peer_addr_owned.as_mut()), + Poll::Pending => Poll::Pending, + } }).await; if let Some(local_addr) = local_addr { @@ -679,8 +682,8 @@ impl EnclaveState { let io_future = async move { let mut recv_queue = io_queue_receive.into_future(); while let (Some(work), stream) = recv_queue.await { - let work_sender_clone = work_sender.clone(); - let tx_clone = tx_return_channel.clone(); + let work_sender = work_sender.clone(); + let tx_return_channel = tx_return_channel.clone(); let enclave_clone = enclave_clone.clone(); recv_queue = stream.into_future(); let (coresult, mut state, buf) = work; @@ -690,7 +693,7 @@ impl EnclaveState { let mut input = IOHandlerInput { enclave: enclave_clone.clone(), tcs: &mut state, - work_sender: &work_sender_clone, + work_sender: &work_sender, }; let handler = Handler(&mut input); let (_handler, result) = { @@ -699,7 +702,7 @@ impl EnclaveState { }; let ret = match result { Ok(ret) => { - work_sender_clone + work_sender .send(Work { tcs: state, entry: CoEntry::Resume(usercall, ret), @@ -728,7 +731,7 @@ impl EnclaveState { Err(EnclaveAbort::MainReturned) => Err(EnclaveAbort::MainReturned), Err(EnclaveAbort::Secondary) => Err(EnclaveAbort::Secondary), }; - let _ = tx_clone.send((ret, state.mode)); + let _ = tx_return_channel.send((ret, state.mode)); }; tokio::task::spawn_local(fut); } @@ -760,7 +763,7 @@ impl EnclaveState { Ok((0, 0)) } }; - let _ = tx_clone.send((ret, state.mode)); + let _ = tx_return_channel.send((ret, state.mode)); }; tokio::task::spawn_local(fut); } @@ -1156,7 +1159,7 @@ impl<'tcs> IOHandlerInput<'tcs> { if let Some(stream_ext) = self .enclave .usercall_ext - .bind_stream(&addr, local_addr_str.as_mut())? + .bind_stream(addr, local_addr_str.as_mut())? { if let Some(local_addr) = local_addr { local_addr.set(local_addr_str.unwrap().into_bytes()); @@ -1164,8 +1167,7 @@ impl<'tcs> IOHandlerInput<'tcs> { return Ok(self.alloc_fd(AsyncFileDesc::listener(stream_ext)).await); } - // !!! see if there's a better way - let socket = tokio::net::TcpListener::bind(&addr.to_socket_addrs()?.as_mut_slice()[0]).await?; + let socket = tokio::net::TcpListener::bind(addr).await?; if let Some(local_addr) = local_addr { local_addr.set(socket.local_addr()?.to_string().into_bytes()); } @@ -1205,7 +1207,7 @@ impl<'tcs> IOHandlerInput<'tcs> { let mut local_addr_str = local_addr.as_ref().map(|_| String::new()); let mut peer_addr_str = peer_addr.as_ref().map(|_| String::new()); if let Some(stream_ext) = self.enclave.usercall_ext.connect_stream( - &addr, + addr, local_addr_str.as_mut(), peer_addr_str.as_mut(), ).await? { @@ -1218,18 +1220,7 @@ impl<'tcs> IOHandlerInput<'tcs> { return Ok(self.alloc_fd(AsyncFileDesc::stream(stream_ext)).await); } - // try to connect to all socket addresses one by one - let mut stream = None; - for socket_addr in addr.to_socket_addrs()? { - stream = Some(tokio::net::TcpStream::connect(&socket_addr).await); - if stream.as_ref().unwrap().is_ok() { - break; - } - } - let stream = match stream { - None => return Err(IoErrorKind::InvalidInput.into()), - Some(s) => s? - }; + let stream = tokio::net::TcpStream::connect(addr).await?; if let Some(local_addr) = local_addr { match stream.local_addr() { diff --git a/sgxs-tools/src/sgx_detect/tests/mod.rs b/sgxs-tools/src/sgx_detect/tests/mod.rs index d4779496..18356f64 100644 --- a/sgxs-tools/src/sgx_detect/tests/mod.rs +++ b/sgxs-tools/src/sgx_detect/tests/mod.rs @@ -746,7 +746,7 @@ impl RunEnclaveProdWl { let mut builder = EnclaveBuilder::new_from_memory(enclave); builder.attributes(sig.attributes).sigstruct(sig); - let mut lib = builder.build_library(enclave_loader)?; + let lib = builder.build_library(enclave_loader)?; unsafe { match lib.call(!0, 0, 0, 0, 0) { From 421ce599a45064890ed7df43af19207c60701c69 Mon Sep 17 00:00:00 2001 From: Mohsen Zohrevandi Date: Tue, 7 Apr 2020 10:29:08 -0700 Subject: [PATCH 4/4] use futures::lock::Mutex exclusively --- enclave-runner/src/usercalls/mod.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/enclave-runner/src/usercalls/mod.rs b/enclave-runner/src/usercalls/mod.rs index 440e78d4..d2c46d1c 100644 --- a/enclave-runner/src/usercalls/mod.rs +++ b/enclave-runner/src/usercalls/mod.rs @@ -27,10 +27,10 @@ use std::task::{Poll, Context, Waker}; use failure; use fnv::FnvHashMap; -use crate::futures::StreamExt; +use futures::StreamExt; +use futures::lock::Mutex; use futures::future::{Either, FutureExt, Future, poll_fn}; use tokio::prelude::{AsyncRead, AsyncWrite}; -use tokio::sync::Mutex; use tokio::sync::mpsc as async_mpsc; use tokio::stream::Stream as TokioStream; @@ -124,7 +124,7 @@ impl AsyncRead for Stdin { } lazy_static::lazy_static! { - static ref STDIN: futures::lock::Mutex = { + static ref STDIN: Mutex = { let (mut tx, rx) = async_mpsc::channel(8); thread::spawn(move || { let mut buf = [0u8; BUF_SIZE]; @@ -138,7 +138,7 @@ impl AsyncRead for Stdin { }; } }); - futures::lock::Mutex::new(AsyncStdin { rx, buf: VecDeque::new() }) + Mutex::new(AsyncStdin { rx, buf: VecDeque::new() }) }; } @@ -170,8 +170,8 @@ pub trait AsyncStream: AsyncRead + AsyncWrite + 'static + Send + Sync { fn poll_read_alloc(self: Pin<&mut Self>, cx: &mut Context) -> Poll>> { let mut v: Vec = vec![0; 8192]; - self.poll_read(cx, v.as_mut_slice()).map(move |size| { - size.map(|size| { v.truncate(size); v }) + self.poll_read(cx, v.as_mut_slice()).map(move |res| { + res.map(|size| { v.truncate(size); v }) }) } } @@ -268,13 +268,13 @@ impl AsyncStreamAdapter { } struct AsyncStreamContainer { - inner: futures::lock::Mutex>>, + inner: Mutex>>, } impl AsyncStreamContainer { fn new(s: Box) -> Self { AsyncStreamContainer { - inner: futures::lock::Mutex::new(Box::pin(AsyncStreamAdapter { + inner: Mutex::new(Box::pin(AsyncStreamAdapter { stream: s.into(), read_queue: VecDeque::new(), write_queue: VecDeque::new(), @@ -355,13 +355,13 @@ impl AsyncListenerAdapter { } struct AsyncListenerContainer { - inner: futures::lock::Mutex>>, + inner: Mutex>>, } impl AsyncListenerContainer { fn new(l: Box) -> Self { AsyncListenerContainer { - inner: futures::lock::Mutex::new(Pin::new(Box::new(AsyncListenerAdapter { + inner: Mutex::new(Pin::new(Box::new(AsyncListenerAdapter { listener: l.into(), accept_queue: VecDeque::new(), }))),